- Naive way to store entries in an array
- Define an array of the type
Entry and
a fill pointer
Entry[] bucket = new Entry[ N ]; int NItems = 0;
- Store a new entry in the
next open position:
bucket[ NItems ] = new Entry ( ... , ... ); NItems ++;
- Perform a linear search to
look up an entry by its
key:
get( Key k ) { for ( int i = 0; i < NItems; i++ ) { if ( bucket[i] contains the key ) return the value in bucket[i]; } return null; // not found }
- Define an array of the type
Entry and
a fill pointer
- Evaluation:
- The implementation is similar
to the linked list approach
- The operations get(), put() and remove() are all O(N) --- which is very poor
- The implementation is similar
to the linked list approach
- Hashing
- Hashing is a
technique to
trade off:
- space (memory)
↔
speed
- space (memory)
↔
speed
- In hashing:
- extra memory variables are allocated to improve (reduce) the running time of a search algorithm
- Hashing is a
technique to
trade off:
- Components of a hash table datastructure:
- Bucket array:
- An array of
(fixed) size N
- Each cell of the bucket array is called a bucket
- An array of
(fixed) size N
- Hash function:
- A function that
maps the
keys
into an integer between
[0, N−1]
- The integer between [0, N−1] is used as an index for the bucket array
- A function that
maps the
keys
into an integer between
[0, N−1]
- Bucket array:
- Example:
- Map content:
- { (11,D), (13,C), (23,F), (63,Z), (16,A), (56,C), (7,Q) }
- Bucket array:
10 buckets (N = 10)
Hash function: h(k) = k%10
Storage of the Map content in the hash table:
- Bucket array:
10 buckets (N = 10)
Hash function: h(k) = (k%10 + k/10)%10
Storage of the Map content in the hash table:
- Map content:
- Lookup procedure:
- Given key k
- Compute the hash function value
h(k)
- Find entry (k, ?) starting with bucket "h(k)"
- Given key k
- Example 1: lookup entry for the key
56
Map content:
Lookup procedure:
- Key = 56
- Hash function: (k%10 + k/10)%10
h(56) = (5 + 6)%10 = 1
- Find entry starting with
bucket 1:
- Key = 56
- When is a Map most efficient:
- A Map data structure will
have O(1) access time when:
- Every key (k) hashes into a different bucket index h(k)
Example: (using a hypothethical hash function)
(When 2 or entries are hashed into the same bucket, then an additional search operation within the bucket must be performed)
- A Map data structure will
have O(1) access time when:
- Efficiency requirements in Hashing:
- The hash function used
must generate
a (approximately)
uniformly distributed index values
for the keys stored
- The number of entries stored in the hash table is significantly less than N (= size of the hash table)
The reason why these conditions are necessary for efficiency in hashing is explained next...
- The hash function used
must generate
a (approximately)
uniformly distributed index values
for the keys stored
- What happens when
hash function
is not uniform:
- Different keys
will "hash" (map) into the
same buckey (array) index
These are called collisions
Example:
- Bucket array:
10 buckets (N = 10)
Hash function: h(k) = k/100
Storage of the Map content in the hash table:
(All entries are stored in the bucket 0)
- Result:
- We have to search through all entries in a look up operation !!!
- Bucket array:
10 buckets (N = 10)
- Colliding entries will decrease the search efficiency
- Different keys
will "hash" (map) into the
same buckey (array) index
- What happens when
number of entries
is close to N:
- The shortage of
free buckets will
increase
the number of
collisions
- Colliding entries will decrease the search efficiency
- The shortage of
free buckets will
increase
the number of
collisions