Hash Discrete Mathematics and Its Applications Baojian Hua

Searching A dictionary-like data structure contains a collection of tuple data:,, … keys are comparable and pair-wise distinct supports these operations: new () insert (dict, k, v) lookup (dict, k) delete (dict, k)

Examples ApplicationPurposeKeyValue Phone Bookphonenamephone No. Banktransactionvisa$$$ Dictionarylookupwordmeaning compilersymbolvariabletype om searchkey wordscontents …………

Summary So Far rep ’ op ’ arraysorted array linked list sorted linked list binary search tree lookup()O(n)O(lg n)O(n) insert()O(n) delete()O(n)

What ’ s the Problem? For every mapping (k, v)s After we insert it into the dictionary dict, we don ’ t know it ’ s position! Ex: insert (d, “ li ”, 97), (d, “ wang ”, 99), (d, “ zhang ”, 100), … and then lookup (d, “ zhang ” ); ( “ li ”, 97) … ( “ wang ”, 99) ( “ zhang ”, 100)

Basic Plan Start from the array-based approach Use an array A to hold elements (k, v)s For every key k: if we know its position (array index) i from k then lookup, insert and delete are simple: A[i] done in constant time O(1) … (k, v) i

Example Ex: insert (d, “ li ”, 97), (d, “ wang ”, 99), (d, “ zhang ”, 100), … ;and then lookup (d, “ zhang ” ); … (“li”, 97) ? Problem#1: How to calculate index from the given key?

Example Ex: insert (d, “ li ”, 97), (d, “ wang ”, 99), (d, “ zhang ”, 100), … ;and then lookup (d, “ zhang ” ); … (“li”, 97) ? Problem#2: How long should array be?

Basic Plan Save (k, v)s in an array, index i calculated from key k Hash function: a method for computing index from given keys … (“li”, 97) hash (“li”)

Hash Function Given any key, compute an index Efficiently computable Ideal goals: for any key, the index is uniform different keys to different indexes However, thorough research problem, :-( Next, we assume that the array is of infinite length, so the hash function has type: int hash (key k); To get some idea, next we perform a “ case analysis ” on how different key types affect “ hash ”

Hash Function On “ int ” // If the key of hash is of “int” type, the hash // function is trivial: int hash (int i) { return i; }

Hash Function On “ char ” // If the key of hash is of “char” type, the hash // function comes with type conversion: int hash (char c) { return c; }

Hash Function On “ float ” // Also type conversion: int hash (float f) { return (int)f; } // how to deal with 0.aaa, say 0.5?

Hash Function On “ string ” // Example: “BillG”: // A trivial one, but not so good: int hash (char *s) { int i=0, sum=0; while (s[i]) { sum += s[i]; i++; } return sum; }

Hash Function On “ Point ” // Suppose we have a user-define type: struct Point2d { int x; int y; }; int hash (struct Point2d pt) { // ??? }

From “ int ” Hash to Index Recall the type: int hash (T data); Problems with “ int ” return type At any time, the array is finite no negative index (say -10) Our goal: int i ==> [0, N-1] Ok, that ’ s easy! It ’ s just: abs(i) % N

Bug! Note that “ int ” s range: ~ So abs(-2 31 ) = 2 31 Overflow! The key step is to wipe the sign bit off int t = i & 0x7fffffff; int hc = t % N; In summary: hc = (i & 0x7fffffff) % N;

Collision Given two keys k1 and k2, we compute two hash codes hc1, hc2  [0, N-1] If k1<>k2, but h1==h2, then a collision occurs … (k1, v1) i (k2, v2)

Collision Resolution Open Addressing Re-hash Chaining (Multi-map)

Chaining For collision index i, we keep a separate linear list (chain) at index i … (k1, v1) i (k2, v2) k1 k2

General Scheme k1 k2 k5k8 k43

Load Factor loadFactor=numItems/numBuckets defaultLoadFactor: default value of the load factor k1 k2 k5k8 k43

“ hash ” ADT: interface #ifndef HASH_H #define HASH_H typedef void *poly; typedef poly key; typedef poly value; typedef struct hashStruct *hash; hash newHash (); hash newHash2 (double lf); void insert (hash h, key k, value v); poly lookup (hash h, key k); void delete (hash h, key k); #endif

Hash Implementation #include “hash.h” #define EXT_FACTOR 2 #define INIT_BUCKETS 16 struct hashStruct { linkedList *buckets; int numBuckets; int numItems; double loadFactor; };

In Figure k1 k2 k5k8 k43 buckets loadFactor numItems numBuckets h

“ newHash () ” hash newHash () { hash h = (hash)malloc (sizeof (*h)); h->buckets = malloc (INIT_BUCKETS * sizeof (linkedList)); for (…) // init the array h->numBuckets = INIT_BUCKETS; h->numItems = 0; h->loadFactor = 0.25; return h; }

“ newHash2 () ” hash newHash2 (double lf) { hash h = (hash)malloc (sizeof (*h)); h->buckets=(linkedList *)malloc (INIT_BUCKETS * sizeof (linkedList)); for (…) // init the array h->numBuckets = INIT_BUCKETS; h->numItems = 0; h->loadFactor = lf; return h; }

“ lookup (hash, key) ” value lookup (hash h, key k, compTy cmp) { int i = k->hashCode (); // how to perform this? int hc = (i & 0x7fffffff) % (h->numBuckets); value t =linkedListSearch ((h->buckets)[hc], k); return t; }

Ex: lookup (ha, k43) k1 k2 k5k8 k43 buckets ha hc = (hash (k43) & 0x7fffffff) % 8; // hc = 1

Ex: lookup (ha, k43) k1 k2 k5k8 k43 buckets ha hc = (hash (k43) & 0x7fffffff) % 8; // hc = 1 compare k43 with k8,

Ex: lookup (ha, k43) k1 k2 k5k8 k43 buckets ha hc = (hash (k43) & 0x7fffffff) % 8; // hc = 1 compare k43 with k43, found!

“ insert ” void insert (hash h, poly k, poly v) { if (1.0*numItems/numBuckets >=defaultLoadFactor) // buckets extension & items re-hash; int i = k->hashCode (); // how to perform this? int hc = (i & 0x7fffffff) % (h->numBuckets); tuple t = newTuple (k, v); linkedListInsertHead ((h->buckets)[hc], t); return; }

Ex: insert (ha, k13) k1 k2 k5k8 k43 buckets ha hc = (hash (k13) & 0x7fffffff) % 8; // suppose hc==4

Ex: insert (ha, k13) k13 k1 k5k8 k43 buckets ha hc = (hash (k13) & 0x7fffffff) % 8; // suppose hc==4 k2

Complexity rep ’ op ’ arraysorted array linked list sorted linked list hash lookup()O(n)O(lg n)O(n) O(1) insert()O(n) O(1) delete()O(n) O(1)