Hashing. Data organization in main memory or disk

Transcription

1 Hashing Data organization in main memory or disk sequential, binary trees, The location of a key depends on other keys => unnecessary key comparisons to find a key Question: find key with a single comparison Hashing: the location of a record is computed using its key only Fast for random accesses - slow for range queries EGM Petrakis Hashing

2 Hash Table Hash Function: transforms keys to array indices n h(key) h(key): Hash Function index data EGM Petrakis Hashing 2 m

3 position key record EGM Petrakis Hashing 3 h(key) = key mod 000

4 Good Hash Functions Uniform: distribute keys evenly in space 2 Perfect: two records cannot occupy the same location or ki k j i j : h( ki ) h( 3 Order preserving:, k j ), ) h( k j ki k j i j : h( ki Difficult to find such hash functions Property 2 is the most essential Most functions are no better than h(key) = key mod m Hash collision: k k : h(k ) h(k ) i j i = j ) EGM Petrakis Hashing 4

5 Collision Resolution Open Addressing (rehashing): compute new position to store the key in the table (no extra space) i linear probing ii double hashing 2 Separate Chaining: lists of keys mapped to the same position (uses extra space) EGM Petrakis Hashing 5

6 Open Addressing Computes a new address to store the key if it is occupied (rehashing) if occupied too, compute a new address, until an empty position is found primary hash function: i=h(key) rehash function: rh(i)=rh(h(key)) hash sequence: (h 0,h,h 2 ) = (h(key), rh(h(key)), rh(rh(h(key))) ) To find a key follow the same hash sequence EGM Petrakis Hashing 6

7 Example i=h(key)=key mod 00 rh(i) = (i+) mod 00 key: 93 i=h(93)=93 rh(i)=(93+)=94 Key 93 will occupy position EGM Petrakis Hashing 7

8 Problem : Locate Empty Positions No empty position can be found i the table is full ii check on number of empty positions the hash function fails to find an empty position although the table is not full!! i=h(key) = key mod 000 rh(i) = (i + 200) mod 000 => checks only 5 positions on a table of 000 positions rh(i) = (i+) mod 000 successive positions rh(i) = (i+c) mod 000 where GCD(c,m) = EGM Petrakis Hashing 8

9 Problem 2: Primary Clustering Different keys that hash into different addresses compete with each other in successive rehashes i=h(key) = key mod 00 rh(i) = (i+) mod 00 keys: 990, 99, 992, 993, 994 => EGM Petrakis Hashing

10 Problem 3: Secondary Clustering Different keys which hash to the same hash value have the same rehash sequence i=h(key) = key mod 0 rh(i,j) = (i + j) mod 0 i key 23 : h(23) = 3 rh = 4, 6, 9, 3, ii key 3 : h(3) = 3 rh = 4, 6, 9, 3, EGM Petrakis Hashing 0

11 Linear Probing Store the key into the next free position h 0 = h(key) usually h 0 = key mod m h i = (h i- + ) mod m, i >= S = {22, 35, 30, 99, 02, 452} 8 EGM Petrakis 9 99 Hashing

12 Observation number Different insertion sequences => different hash sequences S ={,3,27,99,8,50,77,2 2,2,3,33,40,53}=>28 probes S 2 ={53,40,33,3,2,22,7 7,50,8,99,27,3,}=> 30 probes of probes H(key) = key mod 3 EGM Petrakis Hashing 2

13 Observation 2 Deletions are not easy: i=h(key) = key mod 0 rh(i) = (i+) mod 0 Action: delete(65) and search(5) Problem: search will stop at the empty position and will not find 5 Solution: 0 70 mark position as deleted rather than empty the marked position can be reused EGM Petrakis Hashing 3

14 Observation 3 Linear probing tends to create long sequences of occupied positions the longer a sequence is, the longer it tends to become P: probability to use a position in the cluster m Β P = B + m EGM Petrakis Hashing 4

15 Observation 4 Linear probing suffers from both primary and secondary clustering Solution: double hashing uses two hash functions h, h 2 and a rehashing function rh EGM Petrakis Hashing 5

16 Double Hashing Two hash functions and a rehashing function primary hash function i=h (key)= key mod m secondary hash function h 2 (key) rehashing function: rh(key) = (i + h 2 (key)) mod m h 2 (m,key) is some function of m, key helps rh in computing random positions in the hash table h 2 is computed once for each key! EGM Petrakis Hashing 6

17 Example of Double Hashing i hash function: h (key) = key mod m h 2 (key) = m div 2 q q = 0 q 0 q = (key div m) mod m ii rehash function: rh(i, key) = (i + h 2 (key)) mod m EGM Petrakis Hashing 7

18 Example (continued) A m = 0, key = 23 h (23) = 3, h 2 (23) = 2 rh(3,2)=(3+2) mod 0 = 5 rehash sequence: 5, 7, 9,, m = 0, key = 3 h (key)=3, h 2 (3)=, rh(3,)=(3+)mod0=4 rehash sequence: 4, 5, 6, EGM Petrakis Hashing 8

19 Performance of Open Addressing Distinguish between successful and unsuccessful search Assume a series of probes to random positions independent events load factor: λ =n/m λ: probability to probe an occupied position each position has the same probability P=/m EGM Petrakis Hashing 9

20 Unsuccessful Search The hash sequence is exhausted let u be the expected number of probes u equals the expected length of the hash sequence P(k): probability to search k positions in the hash sequence EGM Petrakis Hashing 20

21 u = kp(k) = k P() + P(2) + P(2) + P(3) + P(3) + P(3) + L P(k) + P(k) + L + P(k) + L P( probes) + P( 2probes) + L EGM Petrakis Hashing 2

22 u = k u = k P(first k positions ocupied ) = λ κ λ P( k k k probes) = λ k independent events uincreases with λ => performance drops as λ increases EGM Petrakis Hashing 22

23 Successful Search The hash sequence is not exhausted the number of probes to find a key equals the number of probes s at the time the key was inserted plus λ was less at that time consider all values of λ λ s = (u + )dx = + ln( ) λ λ λ 0 approximation u: equivalent to unsuccessful search increases with λ EGM Petrakis Hashing 23

24 Performance The performance drops as λ increases the higher the value of λ is, the higher the probability of collisions Unsuccessful search is more expensive than successful search unsuccessful search exhausts the hash sequence EGM Petrakis Hashing 24

25 Experimental Results LOAD FACTOR SUCCESSFUL UNSUCCESSFUL LINEAR i + bkey DOUBLE LINEAR i + bkey DOUBLE 25% % % % % EGM Petrakis Hashing 25

26 Performance on Full Table SUCCESSFUL TABLE UNSUCCESSFUL LOG 2 m SIZE (m) LINEAR i + bkey DOUBLE EGM Petrakis Hashing 26

27 Separate Chaining Keys hashing to the same hash value are stored in separate lists one list per hash position can store more than m records easy to implement the keys in each list can be ordered EGM Petrakis Hashing 27

28 nil nil h(key) = key mod m nil 3 nil 4 nil 5 75 nil nil nil 8 nil 9 49 nil EGM Petrakis Hashing 28

29 Performance of Separate Chaining Depends on the average chain size insertions are independent events let P(c,n,m): probability that a position has been selected c times after n insertions on a table of size m P(c,n,m): probability that the chain has length c => binomial distribution P(c,n, m) = n p c c c q n p=/m: success case q=-p: failure case EGM Petrakis Hashing 29

30 EGM Petrakis Hashing 30 n c c n c m m m c n m n c! m m c n P(c,n, m) + = = λ n c e m m λ m c n + => P(c,n,m)=(/c!)λ c e -λ Poison m n, =>

31 Unsuccessful Search The entire chain is searched the average number of comparisons equals its average length u u = c 0 cp(c, λ) = c 0 λ c e c! λ = λ EGM Petrakis Hashing 3

32 Successful Search Not the whole chain is searched the average number of comparisons equals the length s of the chain at time the key was inserted plus the performance at the time a key was inserted equals that of unsuccessful search! λ s = (u λ + )dx = (x + )dx = + 0 EGM Petrakis Hashing 32 λ λ 0 λ 2

33 Performance The performance drops with the length of the chains worst case: all keys are stored in a single chain worst case performance: O(N) unsuccessful search performs better than successful search!! WHY? no problem with deletions!! EGM Petrakis Hashing 33

34 Coalesced Hashing The hash sequence is implemented as a linked list within the hash table no rehash function the next hash position is the next available position in linked list extra space for the list h(key) = key mod 0 keys: 9, 29, 49, EGM Petrakis Hashing 34

35 avail initialization 0 nilkey - nilkey nilkey 8 List of empty positions initially: avail = 9 h(key) = key mod 0 keys: 4,29,34,28,42,39,84,38 0 nilkey - nilkey Holds lists of rehashing positions and list of empty positions EGM Petrakis Hashing 35

36 Performance of Coalesced Hashing Unsuccessful search 2λ e 4 λ Successful search probes/search e 2λ λ λ 4 probes/search EGM Petrakis Hashing 36