Topic HashTable and Table ADT

Transcription

1 Topic HashTable and Table ADT

2 Hashing, Hash Function & Hashtable

3 Search, Insertion & Deletion of elements based on Keys So far, By comparing keys! Linear data structures Non-linear data structures Time complexity?

4 Search, Insertion & Deletion of elements based on Keys A different approach: By calculating the location from keys! Time complexity?

5 Search, Insertion & Deletion of elements by calculating the location from keys 0 1 Search Key Location Calculator 2 3. N-1

6 Hashing The technique used for ordering and accessing elements in an array of some fixed size N. Hashtable By manipulating the key of an element to identify its location in the array. Each key is are mapped to an array position (0.. N-1) by a hash function. Hash Function In a relatively constant amount of time.

7 Hashtable The array of elements based on hashing. - unordered, sparse table! N-1 N = Hashtable size (N= The fixed size of the array) Hashtable

8 Keys of Elements K = The set of keys of elements The size of K is relatively large or even unbounded. K = 9-digit numbers K = 1,000,000,000 K = Arbitrary character strings of arbitrary length K = unbounded

9 Keys Depending on the application, the keys might be Integers letters strings and so on

10 Elements E = The number of elements to be stored E is significantly less than K. K E

11 Size of Hashtable N = The size of hashtable N is at least as great as the maximum number of elements to be stored, i.e. E. K E N-1

12 Hash Function A function used to manipulate the key of an element to identify its location in the array (hashtable).

13 Hash Function A Key Value in the set of possible keys K h An Integer Value between 0 and N N-1. Hash Function Hashing a key to an array index h: K {0, 1,, N-1}

14 Example Employees using their SSNs as a key: K = The set of keys = 10 9 = 1,000,000,000 Let E = The number of employees to be stored = 10,000 E << K Let N= 10,000. Hash function h: SSN {0, 1,, 9999} Let h (key) = key % 10000

15 Example Employees using their five digit ID numbers as a key: K = The set of keys = 10 5 = 100,000 Let E = The number of employees to be stored = 100 E << K Let N= 100. Hash function h: ID {0, 1,, 99} Let h (key) = key % 100

16 Hash Function Methods Selecting digits Folding Method - Add digits Middle square method Multiplication method Division method - Modulo arithmetic

17 Access using Hash Function Hash function has two uses: As a method of determining where to store the element. As a method of accessing the element.

18 Access using Hash Function Key h N-1 Hashtable

19 Perfect Hash Function Transforms different keys to different numbers.

20 Collision

21 Collisions The condition resulting when two or more keys produce the same hash location. When two or more items should be kept in the same location, esp. in hash tables, that is, when two or more different keys hash to the same value.

22 Why Collisions? In general: K N The mapping defined by hash function H: K {0, 1,, N-1} is a many-to-one mapping! There will exist many pairs of two distinct keys K1 and K2 s.t. H(K1)= H(K2). K E N-1..

23 Example Employees using their SSNs as a key: K = The set of keys = 10 9 = 1,000,000,000 Let N= 10,000. K N {0, 1,, 9999} is a many- Hash function h: SSN to-one mapping! There will exist many pairs of two distinct keys SSN1 and SSN2 s.t. h(ssn1)= h(ssn2). h( ) = 1234, h( ) = 1234,

24 Example Employees using their five digit ID numbers as a key: K = The set of keys = 10 5 = 100,000 Let N= 100. K N {0, 1,, 99} is a many-to- Hash function h: ID one mapping! There will exist many pairs of two distinct keys ID1 and ID2 s.t. h(id1)= h(id2). h(91234) = 1234, h(11234) = 1234,

25 Collisions? The hash function The hash table size

26 Collision Resolution Schemes

27 How to Resolve Collisions? Two approaches to collision resolution : Through open addressing Closed hashing Through restructuring the hash table (chained addressing) Open hashing

28 Example N = 101 & h(key) = Key mod mod 101 = h Hashtable

29 Example N = 101 & h(key) = Key mod mod 101 = h ? Hashtable

30 Collision Resolution through Open Addressing A method of finding an open location for insertion into a hashtable after a collision has occurred. How to find an open location? (Probe) Linear probing Quadratic probing Doubling hashing Random probing

31 1. Linear Probing for Open Addressing An open addressing technique in which we continue from the hash location on looking for the next available position sequentially. The size of step = 1 The probe sequence: HT[ h ( SearchKey ) ] HT[ h ( SearchKey ) + 1 ] HT[ h ( SearchKey ) + 2 ] HT[ h ( SearchKey ) + 3 ]

32 Example: Insertion h(key) = Key mod h ?

33 Example: Insertion h(key) = Key mod h ?

34 Example: Deletion 4567 h(key) = Key mod h

35 Example: Search 3658 h(key) = Key mod h

36 Status of Each Location Each location has Three states: valid empty deleted

37 Example: Deletion 4567 & Search 3658 h(key) = Key mod valid 3658 h deleted empty

38 Example: Insert 4567 Again h(key) = Key mod valid 4567 h deleted empty

39 Example: Insert 4567 Again h(key) = Key mod valid 4567 h valid empty

40 Clustering Problem with Linear Probing The tendency of elements to become unevenly distributed in the hashtable, with many elements clustering around a single hash location. Clustering causes long probe searches!

41 2. Quadratic Probing for Open Addressing An open addressing technique in which we continue from the hash location on looking for the next available position sequentially. The size of step = 1 2, 2 2, 3 2 The probe sequence: HT[ h ( SearchKey ) ] HT[ h ( SearchKey ) ] HT[ h ( SearchKey ) ] HT[ h ( SearchKey ) ]

42 Example: Insertion h(key) = Key mod h ?

43 Example: Insertions h(key) = Key mod h

44 Example: Insertions h(key) = Key mod h ?

45 Quadratic Probing Virtually eliminates clustering! Cannot guarantee successful insertion if the hash table is half full or more.

46 3. Double Hashing for Open Addressing An open addressing technique in which we continue from the hash location on looking for the next available position sequentially. The size of step = h (SearchKey) The probe sequence: HT[ h ( SearchKey ) ] HT[ h ( SearchKey ) + h (SearchKey) ] HT[ h ( SearchKey ) + 2 * h (SearchKey) ] HT[ h ( SearchKey ) + 3 * h (SearchKey) ] The probe sequence is key-dependent.

47 Example: Insertion h(key) = Key mod 11 h (key) = 7 - (Key mod 7) ? 7 14 h Hashtable

48 Example: Insertion h(key) = Key mod 11 h (key) = 7 - (Key mod 7) ? 7 91 h ? Hashtable

49 Rehashing What happens the hash table is full or very full? Rehashing! Enlarge the hashtable size. Rehashing is Create a new larger hash table. Insert each element in the old hash table into the new hash table. How larger hash table? Double the hashtable size.

50 Collision Resolution through Restructuring the Hashtable Change the structure of the hashtable so that it can accommodate more tan one element in the same location! Two ways: Using buckets Using separate chaining

51 1. Using Buckets A technique to resolve collisions by implementing a hashtable as an array of arrays. A bucket is an element of a hashtable that is itself an array.

52 Example: Insertion h(key) = Key mod h Bucket size = 3

53 Using Buckets The size of bucket Too small? Too big?

54 2. Using Separate Chaining A technique to resolve collisions by implementing a hashtable as an array of pointers, each pointer is the head of a linked list of records with keys that hash to that location. Each linked list is called a chain.

55 Example: Insertion h(key) = Key mod h

56 Separate Chaining Using a linked list A unsorted linked list A sorted linked list

57 Good Hash Functions? A good hash function avoids collisions. A good hash function tends to spread keys evenly. A good hash function is easy to compute. The running time should be O(1).

58 Good Hash Functions The calculation of the hash function should involve the entire search key. If a hash function uses modulo arithmetic, the base (the hashtable size) should be prime. f(key) % table_size

59 Size of Hashtable? Too big? Memory waste Too small? More collisions & rehashing Should be as large as practical & prime number!

60 Hash Table Implementation

61 Hash Table ADT template < class DT, class KT > class HashTbl { public: HashTbl ( int inittablesize ); ~HashTbl ();

62 Hash Table ADT void insert (const KT& searchkey, const DT &newdataitem); bool remove ( KT searchkey ); bool retrieve ( KT searchkey, DT &dataitem ); void clear (); bool isempty () const; bool isfull () const; void showstructure () const;

63 Hash Table ADT }; private: int tablesize; vector<list< pair<kt,dt> >> datatable;

64 Analysis of Hashing

65 Search - Time Analysis Search operation: The worst-case time Every key gets hashed to the same array index. O(N) linear time The average-case time O(2-5) constant time

66 Insert - Time Analysis Insert operation: The worst-case time Every key gets hashed to the same array index. O(N) linear time O(1) for separate chaining (insert at the front always) The average-case time O(2-5) constant time

67 Delete - Time Analysis Delete operation: The worst-case time Every key gets hashed to the same array index. O(N) linear time The average-case time O(2-5) constant time

68 Load Factor of a Hashtable In general, hashtables have some unused locations. Load factor = The number of occupied hashtable locations (entries) / The size of the hashtable!

69 Search - Average Case The average number of hashtable elements examined for Search with linear probing: (1 + 1/ (1 - lf)) / 2 for successful search (1 + 1/ (1 - lf)2) / 2 for unsuccessful search

70 Search - Average Case The average number of hashtable elements examined for Search with quadratic probing and double hashing: - log (1 - lf) / lf for successful search 1/(1 - lf) for unsuccessful search

71 Search - Average Case The average number of hashtable elements examined for Search with separate chaining: 1 + lf / 2 for successful search lf for unsuccessful search

72 Search - Average Case load factor linear probing double hashing separate chaining

73 FindMin & FindMax - Time Analysis FindMin & FindMax operations: O(N) linear time

74 Traverse - Time Analysis Ordered traversal operation: O(N) linear time