sets, maps and hash tables
DESCRIPTION
Sets, Maps and Hash Tables. Sets. We have learned that different data struc-tures have different advantages – and drawbacks Choosing the proper data structure depends on typical usage patterns - PowerPoint PPT PresentationTRANSCRIPT
Sets, Maps and Hash Tables
RHS – SWC 2
Sets
• We have learned that different data struc-tures have different advantages – and drawbacks
• Choosing the proper data structure depends on typical usage patterns
• Array- and list-oriented data structures are appropriate when the order of elements matter – but that is not always the case
RHS – SWC 3
Sets
• A Set is a data structure which can hold an unordered collection of elements
• Not having to worry about ordering can improve performance of other operations
• On a Set, we want to be able to– Insert an element– Delete an element– Check if a given element is in the Set
RHS – SWC 4
Sets
public interface Set<T>
{
void add(T element);
void remove();
boolean contains(T element);
Iterator<T> iterator();
}
RHS – SWC 5
Sets
• It turns out that insertion, deletion and check for containment can be done in O(log(n)), or even faster!
• Depends on the underlying implemen-tation of the interface
• In Java, implementation is either– HashSet (based on Hash Tables)– TreeSet (based on Trees)
RHS – SWC 6
Sets• A Set iterator is ”simpler” than e.g. a List
iterator– Elements will occur in ”random” order– No add method – we just call add on the Set
itself– No previous method – does not make sense
• The Set iterator does however have a delete method (why?)
RHS – SWC 7
Sets – Quality tip
• When using a Set, we must choose a spe-cific implementation (HashSet or TreeSet)
• However, the definition should look like:
Set<Car> cars = new HashSet<Car>();
RHS – SWC 8
Sets – Quality tip
Set<Car> cars = new HashSet<Car>();
• Why…? We should in general only refer to the interface, not the implementation
• Easy to switch implementation!
RHS – SWC 9
Maps
• A Map is a data structure which stores associations between– A collection of keys– A collection of values
• All keys map to a value
• Keys are unique (values are not)
RHS – SWC 10
Maps
K1
K2
K3
K4
V1
V3
V2
RHS – SWC 11
Map
public interface Map<K,V>
{
void put(K key,V value);
V get(K key);
void remove(K key);
Set<K> keySet();
}
RHS – SWC 12
Map
• The keySet method returns a Set containing all keys in the Map
• You must then iterate through this Set, in order to get all values stored in the Map
RHS – SWC 13
Map
Map<String,Car> carMap = new HashMap<String,Car>();
...
Set<String> regNumbers = carMap.keySet();
for (String regNo : regNumbers)
{
Car aCar = carMap.get(regNo);
... // Do something with the Car object
}
RHS – SWC 14
Hash Tables
• A Set and a Map are both abstract data types – we need a concrete implemen-tation in order to use them
• In the Java library, two implementations are available:– Sets: HashSet, TreeSet– Maps: HashMap, TreeMap
RHS – SWC 15
Hash Tables
• The implementations HashSet and HashMap are based on a Hash Table
• A Hash Table is based on the below ideas:– Create an array of length N, which can store
objects of some type T– Find a mapping from T to the interval [0; N-1]
(a Hash Function f)– Store an object t of type T in the position f(t)
RHS – SWC 16
Hash Tables
0 1 2 3 4
Car1 Car2
Car3f(Car1) = 3
f(Car2) = 0
f(Car3) = 2
RHS – SWC 17
Hash Tables
• A Hash Table is thus ”almost” an array
• Instead of having an index directly available, we must calculate it
• If calculation can be done in constant time, then all basic operations (insert, delete, lookup) can be done in constant time!
• Better than tree-based implementations, which have O(log(N))
RHS – SWC 18
Hash Tables
• However, there are some issues:– How do we define a
good mapping from the objects to [0; N-1]?
– What happens if we try to store two objects at the same position?
RHS – SWC 19
Hash Functions
• Before finding a good mapping – i.e. a good hash function – we must consider the size of the array
• For good performance, the array should at least be as large as the maximal number of objects stored
• Rule of thumb is about 30 % larger
• Size should be a prime number (???)
RHS – SWC 20
Hash Functions
• What if the expected number of objects is unknown in advance?
• We can expand a hash table dynamically
• If the hash table in running out of space, double the capacity
• Start out with a reasonably large array (space is cheap…)
RHS – SWC 21
Hash Functions
• Having handled the choice of N, how do we define a proper hash function?
• Properties of a hash function:– Must map all objects of type T to the interval
[0; N-1]– Should map objects as uniformly as possible
to the interval [0; N-1]
RHS – SWC 22
Hash Functions
• We can enforce the mapping to [0;N-1] by using the modulo operator:
f(t) = g(t) % N
• g(t) can then produce any integer value
• How do we achieve a uniform distribution?
• Theory for this is complicated, but there are some general rules to follow
RHS – SWC 23
Hash Functions
• A good hash function should be ”almost ran-dom”, but deterministic– ”Almost random” –
values are well distri-buted in the interval
– Deterministic – always produce the same output for the same input
RHS – SWC 24
Hash Functions
• In Java, all objects have a hashCode method– Defined in Object class– Can be overrided– Returns an integer (the Hash Code)– We must use modulo on the value ourselves
RHS – SWC 25
Hash Functions
• Hash function for integers:– The number itself…
• Hash function for strings:final int HASH_MULTIPLIER = 31;
int h = 0;
for (int i = 0; i < s.length; i++)
h = (HASH_MULTIPLIER * h) + s.charAt(i);
RHS – SWC 26
Hash Functions
• Hash code for an object can be calculated by combining hash codes for instance fields
• Combine values in a way similar to the algorithm used to find string hash codes
RHS – SWC 27
Hash Functions
public int hashCode()
{
final int MULTIPLIER = 31;
int h1 = regNo.hashCode();
int h2 = mileage;
int h3 = model.hashCode();
int h = h1*MULTIPLIER + h2;
h = h*MULTIPLIER + h3;
return h;
}
RHS – SWC 28
Hash Functions
• But wait…what about numeric overflow?
• We multiply a ”random” integer value with a number…?
• Does not really matter…
• As long as the algorithm is deterministic, overflow is not a problem
• Just helps ”scrambling” the value
RHS – SWC 29
Hash Functions
• Common pitfalls:– Remember to define a hashCode function – If you forget, the hashCode implementation in
Object is used– Based solely on memory location of object– Two objects with the same value of instance
fields will produce different hash codes…
RHS – SWC 30
Hash Functions
• Common pitfalls:– The hashCode function must be
”compatible” with your equals function– If a.equals(b) it must hold that a.hashCode() == b.hashCode()
– If not, duplicates are allowed!– The reverse condition is not required; two
different objects may have the same hash code
RHS – SWC 31
Hash Functions
• In general, you must remember to:– Either define the hashCode and the equals method
– Or not define any of them!
RHS – SWC 32
Handling collisions
• Even with a good hash function, we will still experience collisions
• Collision: two different objects t1 and t2 have the same hash code
• We will then try to store both objects in the same position in the array
• Now what…?
RHS – SWC 33
Handling collisions
• What we store in each position in the array is not the objects themselves, but a linked list of objects
• Objects with the same hash code h are stored in the linked list in position h
• With a good hash function, the average length of non-empty lists is less than 2
RHS – SWC 34
Handling collisions
0 1 2 3 4
Car1Car2 Car3
Car4
Car5
Car6
RHS – SWC 35
Handling collisions
• Basic operations (insert, delete, lookup) follow this structure:– Calculate hash code for the object– Find the corresponding position in the array
• Insert: Insert element at the end of list• Delete/Lookup: Iterate through list until element is
found, or end of list is reached
RHS – SWC 36
Handling collisions
• Basic operations are thus not done in truly constant time
• However, if a proper hash function is used, running time is constant in practice
• Use hash-based implementations unless special circumstances apply– Hard to define hash/equals function– More functionality required