Hash Tables. Reading: Cormen et al, Sections 11.1 and 11.2

Transcription

1 COMP3600/6466 Algorithms 2018 Lecture 10 1 Hash Tables Reading: Cormen et al, Sections 11.1 and 11.2 Many applications require a dynamic set that supports only the dictionary operations Insert, Search and Delete. This lecture and the next investigate hash tables which provide efficient implementations of these operations so that they have running time O(1). A hash table is a generalization of the simpler notion of an ordinary array. Thus, as motivation, direct-address tables are first discussed. Directly addressing into an array makes effective use of the ability to index an arbitrary entry in the array in O(1) time, independent of the size of array n. Direct addressing is a simple technique that works well when the universe U = {0, 1,..., m 1} of keys is reasonably small and no two elements have the same key. 1

2 COMP3600/6466 Algorithms 2018 Lecture 10 2 Direct-address tables Cormen et al, p.254 2

3 COMP3600/6466 Algorithms 2018 Lecture 10 3 Direct-address tables 2 To represent a dynamic set that has insertion, deletion, and searching operations, we use a direct-address table, denoted by T [0..m 1], in which each position, or slot, corresponds to a key in the universe U. Direct-Address-Search(T, k) return T [k] Direct-Address-Insert(T, x) T [x.key] = x Direct-Address-Delete(T, x) T [x.key] = Nil Each of these operations takes only O(1) time. 3

4 COMP3600/6466 Algorithms 2018 Lecture 10 4 Hash tables When the universe is large, storing a table T of size U may be impracticable or even impossible. Furthermore, the set K of keys actually stored may be so small relative to U that most of the space allocated for T would be wasted. When the set K of keys stored in a dictionary is much smaller than the universe U of possible keys, a hash table requires much less storage than a direct-address table. With a hash table, the storage requirement can be reduced to Θ( K ), while searching for an element still requires only O(1) time. However, this bound is for the average-case time, whereas for direct addressing it holds for the worst-case time. 4

5 COMP3600/6466 Algorithms 2018 Lecture 10 5 Hash tables 2 With direct-addressing, an element with key k is stored in slot k. With hashing, the element is stored in slot h(k), where h is a hash function that computes the slot from the key. Here, h : U {0, 1,..., m 1} maps the universe of keys into slots of a hash table T [0..m 1]. The size m of the hash table is generally much less than U. We say that an element with key k hashes to slot h(k). We also say that h(k) is the hash value of key k. (Direct addressing can be thought of as a special case where h : {0, 1,..., m 1} {0, 1,..., m 1} is the identity function.) 5

6 COMP3600/6466 Algorithms 2018 Lecture 10 6 Hash tables 3 Cormen et al, p.256 6

7 COMP3600/6466 Algorithms 2018 Lecture 10 7 Collision in hash tables The hash function reduces the range of array indices and hence the size of the array. Instead of size U, the array can have size m. The drawback is that two keys may hash to the same slot. This is called a collision. One would like to avoid collisions altogether, but this is unavoidable when U > m, the case that almost always holds in practice. Still, intuitively, one would like h to be as random as possible so that collisions are minimized. However, since we must deal with collisions, methods for resolving them are necessary. One possible solution is to place all the elements that hash to the same slot into the same linked list. This is called chaining. 7

8 COMP3600/6466 Algorithms 2018 Lecture 10 8 Collision resolution by chaining Cormen et al, p.257) 8

9 COMP3600/6466 Algorithms 2018 Lecture 10 9 Operations on hash tables The dictionary operations on a hash table T are easy to implement when collisions are resolved by chaining. Chained-Hash-Insert(T, x) insert x at the front of the linked list T [h(x.key)] Chained-Hash-Search(T, k) search for an element with key k in the linked list T [h(k)] Chained-Hash-Delete(T, x) delete x from the linked list T [h(x.key)] 9

10 COMP3600/6466 Algorithms 2018 Lecture Operations on hash tables 2 For insertion, the worst-case running time is O(1). (This assumes the element x is not already in the hash table.) For searching, the worst-case time is proportional to the length of the list. For deletion, an element can be deleted on O(1) time, if the list is doubly linked. Note that Chained-Hash-Delete takes as input an element x and not its key k, so it is not necessary to search for x first. If the lists were only singly-linked, it would be necessary to search for x in the list to find its predecessor and update the next attribute of its predecessor. With singly-linked lists, both deletion and searching would have the same asymptotic running times. 10

11 Analysis of simple uniform hashing with chaining Given a hash table with m slots that stores n elements, the load factor of the hash table is α = n/m. Note that α is the average number of elements stored in a chain. Also α can be < 1, = 1, or > 1. The worst-case behaviour of hashing with chaining is terrible: all keys hash to the same slot creating a list of length n. Then the worst-case time for searching is Θ(n), plus the time to compute the hash function. The average-case performance of hashing depends on how well the hash function h distributes the set of keys to be stored among the m slots, on average. For the analysis, we make the assumption of simple uniform hashing: any given element is equally likely to hash into any of the m slots, independent of where any other element has hashed to. 11 COMP3600/6466 Algorithms 2018 Lecture 10 11

12 COMP3600/6466 Algorithms 2018 Lecture Analysis of simple uniform hashing with chaining 2 For j = 0,..., m 1, denote by n j the length of the list T [j], so that n = n 0 + n n m 1, and the average value of n j is α = n/m. Assume it takes O(1) to compute the hash value h(k). The time to search for an element with key k depends linearly on the length n h(k) of the list T [h(k)]. Consider the average number of elements examined by the search procedure, that is, the number of elements in the list T [h(k)] that the algorithm checks to see whether any have a key equal to k. There are two cases to consider. In the first case, the search is unsuccessful. In the second case, the search successfully finds an element with key k. 12

13 COMP3600/6466 Algorithms 2018 Lecture Analysis of simple uniform hashing with chaining 3 Here is a fact that will be needed in the analysis. Let a, b > 0 and α = n/m. Then a + bα = Θ(1 + α). To see this, put c 1 = min{a, b} and c 2 = max{a, b}. Then 0 c 1 (1 + α) a + bα c 2 (1 + α), for n 1. Hence the result. Note that, in the expression Θ(1 + α), we regard m as fixed, so that 1 + α is a function of the single variable n. 13

14 COMP3600/6466 Algorithms 2018 Lecture Analysis of simple uniform hashing with chaining 4 Theorem In a hash table where collisions are resolved by chaining, an unsuccessful search takes average-case time Θ(1 + α), under the assumption of simple uniform hashing. Proof: Under the assumption of simple uniform hashing, any key k not already stored in the table is equally likely to hash to any of the m slots. The average time to search unsuccessfully for a key is the average time to search to the end of the list T [h(k)], which has average length α. Thus the average number of elements searched in an unsuccessful search is α, and the total time required (including the time for computing h(k)) is C 1 + C 2 α, for some positive constants C 1 and C 2. Hence the average-case time for unsuccessful search is Θ(1 + α). 14

15 COMP3600/6466 Algorithms 2018 Lecture Analysis of simple uniform hashing with chaining 5 Theorem In a hash table where collisions are resolved by chaining, a successful search takes average-case time Θ(1 + α), under the assumption of simple uniform hashing. Proof: Assume that the key being searched for is equally likely to be any of the n elements stored in the table. The number of elements examined in a successful search for an element x is one more than the number of elements that appear before x in x s list. (The elements before x in the list were all inserted after x was inserted: insertion takes place at the front of the list.) 15

16 COMP3600/6466 Algorithms 2018 Lecture Analysis of simple uniform hashing with chaining 6 To find the average number of elements examined, we take the average, over the n elements in the table, of 1 plus the average number of elements added to x s list after x was added. This is 1 n n 1 + i=1 n j=i+1 1. m Here, by the assumption of simple uniform hashing, the probability that two keys will hash to the same slot is 1 m. Thus n j=i+1 1 m is the average number of elements added to x s list after x was added. 16

17 Analysis of simple uniform hashing with chaining 7 Now 1 n n 1 + i=1 = nm = nm = nm n j=i+1 n (n i) i=1 ( n n i=1 ( n 2 = 1 + n 1 2m = 1 + α 2 1 2m 1 m ) n i i=1 n(n + 1) 2 ) Thus the average-case time for successful search is Θ(1 + α). 17 COMP3600/6466 Algorithms 2018 Lecture 10 17

18 COMP3600/6466 Algorithms 2018 Lecture Analysis of simple uniform hashing with chaining 8 Assume that the number of hash table slots is at least proportional to the number of elements in the table, that is, n = O(m). Then α = n/m = O(m)/m = O(1). Thus search, successful or not, takes O(1) time on average. Since insertion and deletion (for doubly-linked lists) takes O(1) worst-case time, all the dictionary operations on a hash table take O(1) time on average. 18