E.G.M. Petrakis Hashing 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

E.G.M. Petrakis Hashing 2

Hash Table

Hash Function: transforms keys to array indices

n

.

.

.

4

3

2

1

0

h(key)dataindex

h(key): Hash Function

m

E.G.M. Petrakis Hashing 3

0 4967000 1 2 8421002 3 . . . . . .

395 396 4618396 397 4957397 398 399 1286399 400 401

. .

. .

. . 990 0000990 991 0000991 992 1200992 993 0047993 994 995 9846995 996 4618996 997 4967997 998 999 0001999

position

key record

h(key) = key mod 1000h(key) = key mod 1000

E.G.M. Petrakis Hashing 4

Good Hash Functions

1. Uniform: distribute keys evenly in space

2. Perfect: two records cannot occupy the same location or

3. Order preserving: 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:

)h(k)h(k:kk jiji

)()(:, jiji khkhjikk )()(:, jiji khkhjikk

E.G.M. Petrakis Hashing 5

Collision Resolution

1. Open Addressing (rehashing): compute new position to store the key in the table (no extra space)

i. linear probingii. double hashing

2. Separate Chaining: lists of keys mapped to the same position (uses extra space)

E.G.M. Petrakis Hashing 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: (h0,h1,h2…) = (h(key),

rh(h(key)), rh(rh(h(key)))…) To find a key follow the same hash

sequence

E.G.M. Petrakis Hashing 7

Example

i=h(key)=key mod 100

rh(i) = (i+1) mod 100 key: 193 i=h(193)=93 rh(i)=(93+1)=94 Key 193 will occupy

position 94

0 100 1 101 2 . . .

.

.

. 90 990 91 991 92 992 93 993 94 . . .

.

.

. 100

193

E.G.M. Petrakis Hashing 8

Problem 1: Locate Empty Positions

No empty position can be found i. the table is full

check on number of empty positionsii. the hash function fails to find an empty

position although the table is not full !! i=h(key) = key mod 1000 rh(i) = (i + 200) mod 1000 => checks only 5

positions on a table of 1000 positions rh(i) = (i+1) mod 1000 successive positions rh(i) = (i+c) mod 1000 where GCD(c,m) = 1

E.G.M. Petrakis Hashing 9

Problem 2: Primary Clustering

Different keys that hash into different addresses compete with each other in successive rehashes i=h(key) = key mod 100 rh(i) = (i+1) mod 100 keys: 1990, 1991, 1992,

1993, 1994 => 94

0 100 1 101 2 . . .

.

.

. 90 990 91 991 92 992 93 993 94 . . .

.

.

. 100

E.G.M. 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 10 rh(i,j) = (i + j) mod 10i. key 23 : h(23) = 3

rh = 4, 6, 9, 3, …ii. key 13 : h(13) = 3

rh = 4, 6, 9, 3, …

0 10 1 2 3 53 4 14 5 15 6 46 7 8 9

E.G.M. Petrakis Hashing 11

Linear Probing

Store the key into the next free position h0 = h(key) usually h0 = key mod m

hi = (hi-1 + 1) mod m, i >= 1

0

1 301 2 22 3 102 4 452 5 35 6 7 8 9 99

S = {22, 35, 301, 99, 102, 452}

E.G.M. Petrakis Hashing 12

Observation 1

Different insertion sequences => different hash sequences S1={11,3,27,99,8,50,7

7,22,12,31,33,40,53}=>28 probes

S2={53,40,33,31,12,22,77,50,8,99,27,3,11}=> 30 probes

H(key) = key mod 13H(key) = key mod 13

number

of probes0 17 2

1 27 1 2 12 4 3 3 1 4 40 4 5 31 1 6 53 6 7 33 1 8 99 1 9 8 2

10 22 2 11 11 1 12 50 2

E.G.M. Petrakis Hashing 13

Observation 2

Deletions are not easy: i=h(key) = key mod 10 rh(i) = (i+1) mod 10

Action: delete(65) and search(5) Problem: search will stop at the

empty position and will not find 5 Solution:

mark position as deleted rather than empty the marked position can be reused

0 70

1

2 12

3 33

4 14

5 55

6 65

7 75

8 85

9 5

E.G.M. Petrakis Hashing 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

Βmm

1BP

E.G.M. Petrakis Hashing 15

Observation 4

Linear probing suffers from both primary and secondary clustering

Solution: double hashing uses two hash functions h1, h2 and a

rehashing function rh

E.G.M. Petrakis Hashing 16

Double Hashing

Two hash functions and a rehashing function primary hash function i=h1(key)= key mod m

secondary hash function h2(key)

rehashing function: rh(key) = (i + h2(key)) mod m

h2(m,key) is some function of m, key helps rh in computing random positions in the

hash table h2 is computed once for each key!

E.G.M. Petrakis Hashing 17

Example of Double Hashing

i. hash function: h1(key) = key mod m

q = (key div m) mod m ii. rehash function: rh(i, key) = (i + h2(key)) mod m

0qq

0q2 div m(key)h2

E.G.M. Petrakis Hashing 18

Example (continued)

A. m = 10, key = 23

h1(23) = 3, h2(23) = 2

rh(3,2)=(3+2) mod 10 = 5

rehash sequence: 5, 7, 9, 1, …

m = 10, key = 13

h1(key)=3, h2(13)=1, rh(3,1)=(3+1)mod10=4

rehash sequence: 4, 5, 6,…

E.G.M. Petrakis Hashing 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=1/m

E.G.M. Petrakis Hashing 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

E.G.M. Petrakis Hashing 21

2probes)P(1probes)P(

________________________

P(k)P(k)P(k)

P(3)P(3)P(3)

P(2)P(2)

P(1)

kP(k)u1k

E.G.M. Petrakis Hashing 22

λ11

u

λλ

)ocupied positions 1k P(first

probes) kP(u

1k 1k

k1κ

1k

1k

independent events

u increases with λ =>performance drops as

λ increases

E.G.M. Petrakis Hashing 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 1

λ was less at that time consider all values of λ

)λ1

1ln(

λ1

11)dx(uλ1

sλ

0

increases with λ

u: equivalent to unsuccessful search

approximation

E.G.M. Petrakis Hashing 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

E.G.M. Petrakis Hashing 25

Experimental ResultsSUCCESSFUL UNSUCCESSFUL

LOAD FACTOR

LINEAR i + bkey DOUBLE LINEAR i + bkey DOUBLE

25% 1.17 1.16 1.15 1.39 1.37 1.33

50% 1.50 1.44 1.39 2.50 2.19 2.00

75% 2.50 2.01 1.85 8.50 4.64 4.00

90% 5.50 2.85 2.56 50.50 11.40 10.00

95% 10.50 3.52 3.15 200.50 22.04 20.00

E.G.M. Petrakis Hashing 26

Performance on Full TableSUCCESSFUL

TABLE SIZE (m)

LINEAR i + bkey DOUBLE

UNSUCCESSFUL LOG2m

100 6.60 4.62 4.12 50.50 6.64

500 14.35 6.22 5.72 250.50 8.97

1000 20.15 6.91 6.41 500.50 9.97

5000 44.64 8.52 8.02 2500.5 12.29

10000 63.00 9.21 8.71 5000.50 13.29

E.G.M. Petrakis Hashing 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

E.G.M. Petrakis Hashing 28

0

1

2

3 nil

4 nil

5

6

7

8 nil

9

nil

nil

nil

nil

nil

nil

nil

40 130

91

42

75

192

87 67

49

66 16

372

227417

h(key) = key mod m

E.G.M. Petrakis Hashing 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

cncqpc

nm)n,P(c,

p=1/m: success caseq=1-p: failure case

E.G.M. Petrakis Hashing 30

nc

cnc

m1

1m1

1m

1cnmn

c!1

m1

1m1

c

nm)n,P(c,

λn

c

em1

1

1m1

1

λm

1cn

=> P(c,n,m)=(1/c!)λce-λ

Poison

mn, =>

E.G.M. Petrakis Hashing 31

Unsuccessful Search

The entire chain is searched the average number of comparisons

equals its average length u

λec!λ

cλ)cP(c,u λ

0c0c

E.G.M. Petrakis Hashing 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 1

the performance at the time a key was inserted equals that of unsuccessful search!

λ

0

λ

02λ

11)dx(xλ1

1)dx(uλ1

s

E.G.M. Petrakis Hashing 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!!

E.G.M. Petrakis Hashing 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

0 … … 1 … … 2 49 7 3 … … 4 … … 5 29 2 6 … … 7 59 - 8 … … 9 19 5

h(key) = key mod 10keys: 19, 29, 49, 59

E.G.M. Petrakis Hashing 35

0 nilkey -1 1 nilkey 0 2 . 1 3 . 2 4 . 3 5 . 4 6 . 5 7 . 6 8 . 7 9 nilkey 8

avail

initially: avail = 9

h(key) = key mod 10

keys: 14,29,34,28,42,39,84,38

0 nilkey -1 1 nilkey 0 2 42 -1 3 38 -1 4 14 8 5 84 -1 6 39 -1 7 28 3 8 34 5 9 29 6

initialization

List of empty positions

Holds lists ofrehashingpositions and list of emptypositions

E.G.M. Petrakis Hashing 36

Performance of Coalesced Hashing

Unsuccessful search

Successful search

0.752λ

e41 2λ

0.754λ

8λ1e2λ

probes/search

probes/search