5. Hashing. 5.1 General Idea. 5.2 Hash Function. 5.3 Separate Chaining. 5.4 Open Addressing. 5.5 Rehashing. 5.6 Extendible Hashing. 5.

Transcription

1 5. Hashing 5.1 General Idea 5.2 Hash Function 5.3 Separate Chaining 5.4 Open Addressing 5.5 Rehashing 5.6 Extendible Hashing Malek Mouhoub, CS340 Fall

2 5. Hashing Sequential access : O(n). Binary search : O(log(n)). Direct access : O(1). Malek Mouhoub, CS340 Fall

3 5.1 General Idea Goal : reduce the number of disk access when searching for a particular record. Solution : use information in the record. Hash function : h(k) Transforms a key K into an address. The resulting address is used as the basis for storing and retrieving records. Malek Mouhoub, CS340 Fall

4 5.2 Hash Function Case 1 : h(k) = K For a student record with Id = , we can store it in record number To find a student record with Id = we have to read the st record. If the Id of the record = , we found the record, otherwise, the record does not exist. With only 25,000 students, it is impractical to use more than one million records to store them (waste 99,75 % of disk space). We must define a better hashing function to map the key value (Id) to a smaller range. Malek Mouhoub, CS340 Fall

5 5.2 Hash Function Case 2 : h(k) = K Mod T ablesize For a student record with Id = , we can store it in record number 4567 i.e hashing function h 1 (Id) = Id Mod Is h a good hashing function? Waste less memory space but collision is possible. Collision : Given a hashing function h and keys k 1 and k 2. If h(k 1 ) = h(k 2 ) = r, then k 1 and k 2 have a collision at r under h. We may have student records with Id = , , , and so on. Collision is almost inevitable in most applications. We must have a collision resolution policy before hashing can be used. Malek Mouhoub, CS340 Fall

6 Collision resolution policy Blocking Separate Chaining Open addressing Malek Mouhoub, CS340 Fall

7 Blocking Allow more than one logical record to be stored in a physical record (location). Example : Each physical record in the relative could store three student records (logical records). record-1-1 record-1-2 record-1-3 record-3-1 record-3-2 record-5-1 A physical record should not be larger than a cluster. Can blocking solve the collision problem? Malek Mouhoub, CS340 Fall

8 Blocking Example : r r r r... r r r r Record number 1 contains 1 logical record. Record number 2 contains 900 logical records. Record number 3 contains 5 logical records. Problems : 1. Cannot access the entire physical record in one disk access. 2. The distribution may not be uniform. That is, disk space can be wasted. 3. To update a record which is stored in record number 2 may require a sequential search through 900 records. Malek Mouhoub, CS340 Fall

9 Blocking Ideal case : The hashing function distributes the logical records evenly. That is, it generates a uniform distribution. No overflowing in a physical record, no waste of disk space, and no problem arising from collision. The distribution depends on the hashing function and it is almost impossible to obtain a uniform distribution. Malek Mouhoub, CS340 Fall

10 Methods for generating random distributions Methods to generate a random distribution and reduce the size of the relative file. Prime division. Radix transformation. Truncation. Extraction. Folding. Mid-square method. Combine different methods. Malek Mouhoub, CS340 Fall

11 Prime division Pick a prime number p which is approximately the size of the desired relative file. Divide the record key by p. Add 1 to the remainder and use it as the home address for the given record. h(key) = key Mod p + 1 Note : We assume that all record keys are integer. For a non-numeric key, we can convert it to a numeric key first. Malek Mouhoub, CS340 Fall

12 Prime division Example : 1. Name is the record key. Key = Tom. 2. Use the alphabetical order to convert it to a numeric key. T = 20, o = 15, m = The numeric value of the record key becomes : = 2163 or add the ASCII values of the letters. Malek Mouhoub, CS340 Fall

13 Radix transformation Assume that the value of the record key has a base other than 10. Example : Record key Operation Home address or Malek Mouhoub, CS340 Fall

14 Truncation and extraction Truncation : take the rightmost n digits. Example : for a student record with Id = , we can take the last four digit and store it in record number Extraction : choose some digits from the record key. Example : for a student record with Id = , we can take the last four digit and store it in record number Malek Mouhoub, CS340 Fall

15 Folding and Mid-square method Folding : split the key into parts and add them together. Example : for a student record with Id = , we can add 923 to 456 and store it in record number Mid-square method : square the key value, take the middle r bits as the home address. Malek Mouhoub, CS340 Fall

16 5.3 Separate Chaining Similar to blocking Keep a list of all elements that hash to the same value. Implementation : use linked lists. To perform a find : use the hash function to determine which list to traverse, and then perform a find in this list. To perform an insert : check the appropriate list to see whether the element is already in place. If the element is new, insert it at the front of the list. Malek Mouhoub, CS340 Fall

17 5.3 Separate Chaining A separate chaining hash table hash function : hash(x) = x mod 10 Malek Mouhoub, CS340 Fall

18 5.4 Open Addressing Problems with Separate Chaining : Requires the implementation of a second data structure. Using linked lists affects the performance (in time) of the algorithm because of the time required to allocate new cells. Malek Mouhoub, CS340 Fall

19 5.4 Open Addressing General idea : If a collision occurs, alternative cells are tried until an empty cell is found. Instead of using a single hash function h(x) to calculate the address of the element, h 0 (x), h 1 (x), h 2 (x)... are tried in succession, where : h i (x) = (hash(x) + f(i)) Mod T ablesize f is the collision resolution strategy f(i) = i : linear probing. f(i) = i 2 : quadratic probing f(i) = i hash 2 (x) : double hashing f(0) = 0 Malek Mouhoub, CS340 Fall

20 Linear Probing h i (x) = (hash(x) + i) Mod T ablesize Trying cells sequentially in search of an empty cell. Problem : Primary Clustering Any key that hashes into the cluster will require several attempts to resolve the collision, and then it will add to the cluster. Malek Mouhoub, CS340 Fall

21 Example : inserting keys {89, 18, 49, 58, 69} Empty Table After 89 After 18 After 49 After 58 After Malek Mouhoub, CS340 Fall

22 Quadratic Probing h i (x) = (hash(x) + i 2 ) Mod T ablesize Eliminates the primary clustering problem of linear probing. No guarantee of finding an empty cell once the table gets more than half full, or even before the table gets half full if the table size is not prime. however simpler and faster in practice. Malek Mouhoub, CS340 Fall

23 Example : inserting keys {89, 18, 49, 58, 69} Empty Table After 89 After 18 After 49 After 58 After Malek Mouhoub, CS340 Fall

24 Double Hashing h i (x) = (hash(x) + i hash 2 (x)) Mod T ablesize hash 2 (x) = R (x mod R) R is a prime smaller than TableSize Malek Mouhoub, CS340 Fall

25 Example : inserting keys {89, 18, 49, 58, 69} Empty Table After 89 After 18 After 49 After 58 After Malek Mouhoub, CS340 Fall

26 5.5 Rehashing When the table gets too full : the running time for the operations will start taking too long. Insertions will fail for quadratic probing (if the table gets more than half full). Solution : Build another table that is about twice big and scan down the original hash table. A new hash function is used to compute the new hash value for each element and inserting it in the new table. Running time : O(N) where N is the number of elements to rehash. In general, rehash after N/2 insertions. Rehashing can be used in other data structures (remember the case of the ADT queue... in the midterm). Malek Mouhoub, CS340 Fall

27 5.6 Extendible Hashing If the amount of data is too large to fit in main memory, the main consideration is the number of disk accesses required to retrieve data. Collision could cause several blocks to be examined during a find. Rehashing is extremely expensive since it requires O(N) disk access. Extendible hashing allows a find to be performed in two disk accesses and insertions in few accesses. Malek Mouhoub, CS340 Fall

28 Original data (2) (2) (2) (2) Malek Mouhoub, CS340 Fall

29 After insertion of and directory split (2) (2) (3) (3) (2) Malek Mouhoub, CS340 Fall

30 After insertion of and leaf split (3) (3) (2) (3) (3) (2) Malek Mouhoub, CS340 Fall