the hash table 1 hash table hash table

the hash table 1

hash table

hash table A hash table consists of two major components …

hash table … a bucket array

hash table … and a hash function

hash table Performance is expected to be O(1)

bucket array

bucket array hash table • A bucket array is an array A of size N • A[i] is a bucket, i. e. a <key, value> pair • N is the capacity of A • <k, e> is inserted in A[k] • if keys are well distributed between 0. . N-1 • if keys are unique integers in range 0. . N-1 then each bucket holds at most one entry. • consequently O(1) for get, insert, delete • downside: space is proportional to N • if N is much larger than n (number of entries) we waste space • downside: keys must be in range 0. . N • this may not be the case (think matric number)

bucket array 0 1 (1, D) 2 3 (3, C) 4 5 hash table 6 7 (6, C) (7, Q) 8 9 10 Bucket array of size 11 for the entries (1, D), (3, C), (6, C) and (7, Q) If hashed keys unique entries in range [0. . 11] then each bucket holds at most one entry. Otherwise we have a collision and need to deal with it. 10

collision bucket array hash table When two different entries map to the same bucket we have a collision 11

collision bucket array hash table When two different entries map to the same bucket we have a collision It’s good to avoid collisions 12

hash function

hash function hash table A hash function maps each key to an integer in the range [0, N-1] Given entry <k, e> … h(k) is the index into the bucket array store entry <k, e> in A[h(k)] h is a good hash function if • h maps keys so as to minimise collisions • h is easy to compute/program • h is fast to compute h(k) has two actions 1. map k to a hash code 2. map hash code into range [0, N-1]

hash codes in java hash function hash table But care should be taken as this might not be “good”

a bit of maths … that you know (af 2)

af 2 Let A and B be sets • A function is • a mapping from elements of A • to elements of B • and is a subset of Ax. B • i. e. can be defined by a set of tuples!

af 2 • A is the domain • B is codomain • f(x) = y • y is image of x • x is preimage of y • There may be more than one preimage of y • There is only one image of x • otherwise not a function • There may be an element in the codomain with no preimage • Range of f is the set of all images of A • the set of all results

Injection (aka one-to-one, 1 -1) a b c u v w x y d injection z af 2 a b c d x y z not an injection If an injection then preimages are unique

Injection (aka one-to-one, 1 -1) af 2 Ideally we want our hash function to be • injective (no collisions) • have a small codomain and range • may need to compress range a b c u v w x y d injection z a b c d x y z not an injection If an injection then preimages are unique

back to ads 2

hash code & hash function Just to clear this up (but lets not make too big a deal about it) …

hash code & hash function Just to clear this up (but lets not make too big a deal about it) … We assume hash code is an integer in the codomain Hash function brings hash codes into the range [0, N-1] We will examine just a few hash functions, acting on strings

Polynomial hash codes hash code & hash function Assume we have a key s that is a character String Here is a really dumb hash code public int dumb. Hash(String s){ int code = 0; for (int i=0; i<s. length(); i++) code = code + s. char. At(i); return code; } What would we get for • dumb. Hash(“spot”) • dumb. Hash(“pots”) • dumb. Hash(“tops”) • dumb. Hash(“post”)

Polynomial hash codes hash code & hash function Take into consideration the “position” of elements of the key So, this doesn’t look any different from an every-day number It’s to the base a and the coefficients are the components of the key

Polynomial hash codes hash code & hash function Good values for a appear to be 33, 37, 39, 41

Polynomial hash codes hash code & hash function Small scale experiments on unix dictionary • a = 33 • 25104 words/strings • minimum hash value -9165468936209580338 • maximum hash value 8952279818009261254 • collision count 7 Yikes! Look at that range!!!!

Cyclic shift hash codes hash code & hash function Start moving bits around

Cyclic shift hash codes hash code & hash function

Cyclic shift hash codes Thanks to Arash Partow hash code & hash function

Cyclic shift hash codes hash code & hash function

Cyclic shift hash codes hash code & hash function

Cyclic shift hash codes hash code & hash function

Cyclic shift hash codes hash code & hash function

Cyclic shift hash codes hash code & hash function

Cyclic shift hash codes hash code & hash function

Cyclic shift hash codes hash code & hash function

Compression Functions hash code & hash function So, you think you’ve found something that produces a good hash code … How do we compress its range to fit into our machine?

Compression Functions hash code & hash function Assume we want to limit storage to buckets in range [0, N-1] The division method int i = (int)(hash(s) % N); S[i] = s; NOTE: keep N prime … ideally, but there may be collisions

Compression Functions hash code & hash function Assume we want to limit storage to buckets in range [0, N-1] The multiply add and divide (MAD) method • N is prime • a > 1 is scaling factor • b ≥ 0 is a shift

hash tables Collision handling schemes

Collision handling schemes Separate Chaining hash tables

Collision handling schemes Separate Chaining hash tables bucket[i] is a small map • implemented as a list bucket[i] should be a short list It may be sorted It might be something other than a list

Collision handling schemes Separate Chaining hash tables Let N be number of buckets and n the amount of data stored load factor is n/M Upside: • simple Downside: • requires auxiliary data structures (to resolve collisions) • this may put additional burden on space

Collision handling schemes Separate Chaining A simple view: an array where array elements are linked list locn list 0 1 2 3 4 5 6 7 hash tables

Collision handling schemes Separate Chaining A simple view: an array where array elements are linked list locn list put(Jon, plumber) hash(Jon) = 3 0 1 2 3 4 5 6 7 hash tables

Collision handling schemes Separate Chaining A simple view: an array where array elements are linked list locn list put(Jon, plumber) hash(Jon) = 3 0 1 2 3 4 5 6 7 Jon, plumber hash tables

Collision handling schemes Separate Chaining A simple view: an array where array elements are linked list locn list put(Fred, painter) hash(Fred) = 6 0 1 2 3 4 5 6 7 Jon, plumber hash tables

Collision handling schemes Separate Chaining A simple view: an array where array elements are linked list locn list put(Fred, painter) hash(Fred) = 6 0 1 2 3 Jon, plumber 4 5 6 7 Fred, painter hash tables

Collision handling schemes Separate Chaining A simple view: an array where array elements are linked list locn list put(Joe, prof) hash(Joe) = 1 0 1 2 3 Jon, plumber 4 5 6 7 Fred, painter hash tables

Collision handling schemes Separate Chaining A simple view: an array where array elements are linked list locn list put(Joe, prof) hash(Joe) = 1 0 1 Joe, prof 2 3 Jon, plumber 4 5 6 7 Fred, painter hash tables

Collision handling schemes Separate Chaining A simple view: an array where array elements are linked list locn list put(Ted, cat) hash(Ted) = 3 0 1 Joe, prof 2 3 Jon, plumber 4 5 6 7 Fred, painter hash tables

Collision handling schemes Separate Chaining A simple view: an array where array elements are linked list locn list put(Ted, cat) hash(Ted) = 3 0 1 Joe, prof 2 3 Jon, plumber 4 5 6 7 Fred, painter hash tables

Collision handling schemes Separate Chaining hash tables A simple view: an array where array elements are linked list locn list put(Ted, cat) hash(Ted) = 3 0 1 Joe, prof 2 3 Jon, plumber 4 5 6 7 Fred, painter Ted, cat

Collision handling schemes hash tables Open Addressing

Open Addressing Linear Probing hash tables

Linear Probing Open Addressing hash tables i = hash(key); bucket[i] != null; collision! Try next bucket[(i+1) % N] Try next bucket[(i+2) % N] Try next bucket[(i+N-1) % N]

Linear Probing Open Addressing locn 0 1 2 3 4 5 6 7 key value hash tables

Linear Probing Open Addressing locn put(Jon, plumber) hash(Jon) = 3 0 1 2 3 4 5 6 7 key value hash tables

Linear Probing Open Addressing locn put(Jon, plumber) hash(Jon) = 3 key value Jon plumber 0 1 2 3 4 5 6 7 hash tables

Linear Probing Open Addressing locn put(Fred, painter) hash(Fred) = 6 key value Jon plumber 0 1 2 3 4 5 6 7 hash tables

Linear Probing Open Addressing locn put(Fred, painter) hash(Fred) = 6 key value Jon plumber Fred painter 0 1 2 3 4 5 6 7 hash tables

Linear Probing Open Addressing locn put(Joe, prof) hash(Joe) = 1 key value Jon plumber Fred painter 0 1 2 3 4 5 6 7 hash tables

Linear Probing Open Addressing locn put(Joe, prof) hash(Joe) = 1 key value Joe prof Jon plumber Fred painter 0 1 2 3 4 5 6 7 hash tables

Linear Probing Open Addressing locn put(Ted, cat) hash(Ted) = 3 key value Joe prof Jon plumber Fred painter 0 1 2 3 4 5 6 7 hash tables

Linear Probing Open Addressing locn put(Ted, cat) hash(Ted) = 3 key value Joe prof Jon plumber Fred painter 0 1 2 3 4 5 6 7 hash tables

Linear Probing Open Addressing locn put(Ted, cat) hash(Ted) = 3 key value Joe prof Jon plumber Fred painter 0 1 2 3 4 5 6 7 hash tables

Linear Probing Open Addressing locn put(Ted, cat) hash(Ted) = 3 key value Joe prof 3 Jon plumber 4 Ted cat Fred painter 0 1 2 5 6 7 hash tables

Linear Probing Open Addressing locn put(Jock, dancer) hash(Jock) = 7 key value Joe prof 3 Jon plumber 4 Ted cat Fred painter 0 1 2 5 6 7 hash tables

Linear Probing Open Addressing locn put(Jock, dancer) hash(Jock) = 7 key value Joe prof 3 Jon plumber 4 Ted cat 6 Fred painter 7 Jock dancer 0 1 2 5 hash tables

Linear Probing Open Addressing locn put(Burt, poet) hash(Burt) = 0 key value Joe prof 3 Jon plumber 4 Ted cat 6 Fred painter 7 Jock dancer 0 1 2 5 hash tables

Linear Probing put(Burt, poet) hash(Burt) = 0 Open Addressing locn key value 0 Burt poet 1 Joe prof 3 Jon plumber 4 Ted cat 6 Fred painter 7 Jock dancer 2 5 hash tables

Linear Probing put(Bob, fish) hash(Bob) = 6 Open Addressing locn key value 0 Burt poet 1 Joe prof 3 Jon plumber 4 Ted cat 6 Fred painter 7 Jock dancer 2 5 hash tables

Linear Probing put(Bob, fish) hash(Bob) = 6 Open Addressing locn key value 0 Burt poet 1 Joe prof 3 Jon plumber 4 Ted cat 6 Fred painter 7 Jock dancer 2 5 hash tables

Linear Probing put(Bob, fish) hash(Bob) = 6 Open Addressing locn key value 0 Burt poet 1 Joe prof 3 Jon plumber 4 Ted cat 6 Fred painter 7 Jock dancer 2 5 hash tables

Linear Probing put(Bob, fish) hash(Bob) = 6 Open Addressing locn key value 0 Burt poet 1 Joe prof 3 Jon plumber 4 Ted cat 6 Fred painter 7 Jock dancer 2 5 hash tables

Linear Probing put(Bob, fish) hash(Bob) = 6 Open Addressing locn key value 0 Burt poet 1 Joe prof 3 Jon plumber 4 Ted cat 6 Fred painter 7 Jock dancer 2 5 hash tables

Linear Probing put(Bob, fish) hash(Bob) = 6 Open Addressing locn key value 0 Burt poet 1 Joe prof 2 Bob fish 3 Jon plumber 4 Ted cat 6 Fred painter 7 Jock dancer 5 hash tables

Linear Probing Open Addressing locn key value 0 Burt poet 1 Joe prof 2 Bob fish 3 Jon plumber 4 Ted cat 6 Fred painter 7 Jock dancer 5 hash tables

Linear Probing Open Addressing hash tables What happens with get(key)? 1. 2. 3. 4. i = hash(key); bucket[i] == key … found, return bucket[i] == null … not found, return bucket[i] != null and bucket[i] != key i = (i+1) % N goto 2 “Linear Probing” gets its name because accessing a bucket is viewed as a probe

Linear Probing Open Addressing What happens with remove(key)? We have a special marker “removed” 1. i = hash(key); 2. bucket[i] == key … found bucket[i] = “removed” return 3. bucket[i] == null … not found return 4. bucket[i] != null and bucket[i] != key i = (i+1) % N goto 2 hash tables

Linear Probing Open Addressing What happens with put(key)? 1. Free location j = -1; 2. i = hash(key); 3. bucket[i] == key … found update bucket[i] return 4. bucket[i] == “removed” j = i; i = (i+1) % N goto 3 5. bucket[i] != null && bucket[i] != key i = (i+1) % N goto 3 6. bucket[i] == null // search stops if (j > -1) bucket[j] = <key, e> if (j = -1) bucket[i] = <key, e> hash tables

Linear Probing Open Addressing hash tables So? Advantages • saves space as bucket[i] is only a bucket for a single entry • that is, no additional data structures Disadvantages • removals are complicated • put is complicated • if there are collisions entries might clump together • search can then degenerate from O(1) down to O(N) We might use linear probing when memory is tight and we want FAST access

Open Addressing Quadratic Probing hash tables

Quadratic Probing Open Addressing Quadratic probing iteratively try …. • bucket[(i + f(j)) % N] where • i = hash(key) • j = 0, 1, 2, … • f(j) = j*j hash tables

Open Addressing Double Hashing hash tables

Double Hashing Open Addressing We have a secondary hash function (call it g) i = hash(key) and collision at bucket[i] Try bucket[(i + g(key)) % N] Where g(key) = q – (key % q) Where q is a prime number < N hash tables

Open Addressing So? hash tables

So? Open Addressing hash tables Open addressing saves space, but is complicated, and may be slower In experiments chaining is competitive or faster, depending on load factor If memory is not an issue: • recommend use chaining with low load factor