# Hash Table - PowerPoint PPT Presentation

Title:

## Hash Table

Description:

### Chapter 12 Hash Table – PowerPoint PPT presentation

Number of Views:289
Avg rating:3.0/5.0
Slides: 49
Provided by: Darw2
Category:
Tags:
Transcript and Presenter's Notes

Title: Hash Table

1
Chapter 12
• Hash Table

2
Hash Table
• So far, the best worst-case time for searching is
O(log n).
• Hash tables
• average search time of O(1).
• worst case search time of O(n).

3
Learning Objectives
• Develop the motivation for hashing.
• Study hash functions.
• Understand collision resolution and compare and
contrast various collision resolution schemes.
• Summarize the average running times for hashing
under various collision resolution schemes.
• Explore the java.util.HashMap class.

4
12.1 Motivation
• Let's design a data structure using an array for
which the indices could be the keys of entries.
• Suppose we wanted to store the keys 1, 3, 5, 8,
these.

5
12.1 Motivation
• The space consumption does not depend on the
actual number of entries stored.
• It depends on the range of keys.
• What if we wanted to store strings?
• For each string, we would first have to compute a
numeric key that is equivalent to it.
• java.lang.String.hashCode() computes the numeric
equivalent (or hashcode) of a string by an
arithmetic manipulation involving its individual
characters.

6
12.1 Motivation
• Using numeric keys directly as indices is out of
the question for most applications.
• There isn't enough space

7
12.1 Motivation
8
12.2 Hashing
• A simple hash function
• table size of 10
• h(k) k mod 10

9
12.2 Hashing
• ear collides with cat at position 4.
• There is empty space in the table, and it is up
to the collision resolution scheme to find an
appropriate position for this string.
• A better mapping function
• For any hash function one could devise, there are
always hashcodes that could force the mapping
function to be ineffective by generating lots of
collisions.

10
12.2 Hashing
11
12.3 Collision Resolution
• There are two ways to resolve collisions.
• Find another location for the colliding key
within the hash table.
• store all keys that hash to the same location in
a data structure that hangs off that location.

12
12.3.1 Linear Probing
13
12.3.1 Linear Probing
• As more and more entries are hashed into the
table, they tend to form clusters that get bigger
and bigger.
• The number of probes on collisions gradually
increases, thus slowing down the hash time to a
crawl.

14
12.3.1 Linear Probing
• Insert "cat", "ear", "sad", and "aid"

15
12.3.1 Linear Probing
• Clustering is the downfall of linear probing, so
we need to look to another method of collision
resolution that avoids clustering.

16
17
• Avoids Clustering
• When the probing stops with a failure to find an
empty spot, as many as half the locations of the
table may still be unoccupied.
• A hash to 2,3,6,0,7, and 5 are endlessly
repeated, and an insertion is not done, even
though half the table is empty.

18
• For any given prime N, once a location is
examined twice, all locations that are examined
thereafter are also ones that have been already
examined.

19
12.3.3 Chaining
• If a collision occurs at location i of the hash
table, it simply adds the colliding entry to a
linked list that is built at that location.

20
Running times
• We assume that the hashing process itself
(hashcode and mapping) takes O(1).
• Running time of insertion is determined by the
collision resolution scheme.

21
12.4 The java.util.HashMap Class
• Consider a university-wide database that stores
student records.
• Every student is assigned a unique id (key), with
which is associated several pieces of information
such as name, address, credits, gpa, etc.
• These pieces of information constitute the value.

22
12.4 The java.util.HashMap Class
• A StudentInfo dictionary that stores (id, info)
pairs for all the students enrolled in the
university.
• The operations corresponding to this relationship
can be found in hava.util.MapltK,Vgt

23
12.4 The java.util.HashMap Class
• The Map interface also provides operations to
enumerate all the keys, enumerate all the values,
get the size of the dictionary, check whether the
dictionary is empty, and so on.
• The java.util.HashMap implements the dictionary
abstraction as specified by the java.util.Map
interface. It resolves collisions using chaining.

24
• When the no-arg constructor is used
• Default initial capacity 16
• Default load factor of 0.75.
• The table size is defined as the actual number of
key-value mappings in the has table.

25
• We can choose an initial capacity
• Only uses capacities that are powers of 2.
• 101 becomes 128

26
• An initial capacity of 128.

27
12.4.2 Storage of Entries
• Relevant fields in the HashMap class.
• threshold is the size threshold
• Product of the capacity and the threshold load
factor (N t)

28
12.4.2 Storage of Entries
• Entry table sets up an array of chains.
• Map.EntryltK,Vgt is defined inside the MapltK,Vgt
interface.
• next holds a reference to the next Entry in its

29
• Example
• Name serves as a key to the phone number value.

30
31
• If the key argument is null, a special object,
NULL_KEY is returned, otherwise the argument key
is returned as is.

32
33
• Example
• h 25 and length 16
• The binary representation of h and length-1
(11001 and 01111).

34
• Since length is a power of 2, the binary
representation of length will be 100...0 with k
zeros.
• Any h is expressible as 2c k r.
• r is a result of the bit-wise and, since the 2c
k part is a higher order bit that will be zeroed
out in the process.

35
36
• The if statement triggers a rehashing process if
the size is equal to or greater than the
threshold.

37
12.4.4 Rehashing
38
12.4.4 Rehashing
39
12.4.5 Searching
40
12.5 Quadratic Probing Repetition of Probe
Locations
• Quadratic probing only examines N/2 locations of
the table before starting to repeat locations.
• Suppose a key is hashed to location h, where
there is a collision.
• Following locations are examined.

41
12.5 Quadratic Probing Repetition of Probe
Locations
• If two different probes (i and j) end up at the
same location?

42
12.5 Quadratic Probing Repetition of Probe
Locations
• Since N is a prime number, it must divide one of
the factors (i j) or (i - j).
• N divides (i - j) only when at least N probes
• N divides (i j) when (i j N), at the very
least.
• j N - i

43
12.6 Summary
• A hash table implements the dictionary operations
of insert, search, and delete on (key, value)
pairs.
• Given a key, a hash function for a given hash
table computes an index into the table as a
function of the key by first obtaining a numeric
hashcode, and then mapping this hashcode to a
table location.

44
12.6 Summary
• When a new key hashes to a location in the hash
table that is already occupied, it is said to
collide with the occupying key.
• Collision resolution is the process used upon
collision to determine an unoccupied location in
the hash table where the colliding key may be
inserted.
• In searching for a key, the same hash function
and collision resolution scheme must be used as
for its insertion.

45
12.6 Summary
• A good hash function must be O(1) time and must
distribute entries uniformly over the hash table.
• Open addressing relocates a colliding entry in
the hash table itself. Closed addressing stores
all entries that hash to a location, in a data
structure that hangs off that location.
• Linear probing and quadratic probing are
instances of open addressing, while chaining is

46
12.6 Summary
• Linear probing leads to clustering of entries
with the clusters becoming increasingly larger as
more and more collisions occur. Clustering
• Quadratic probing attempts to reduce clustering.
On the other hand, quadratic probing may leave as
many as half the hash table empty while reporting
failure to insert a new entry.

47
12.6 Summary
• Chaining is the simplest way to resolve
collisions and also results in better performance
than linear probing or quadratic probing.
• The worst-case search time for linear probing,
quadratic probing, and chaining is O(n).
• The load factor of a hash table is the ratio of
the number of keys, n, to the capacity, N.

48
12.6 Summary
• The average performance of chaining depends on
the load factor. For a perfect hash function that
always distributes keys uniformly, the average
search time for chaining is O(1).