Maps,Tries Searching, (hashing)
Searching is a fundamentally important operation
We want to search quickly, very very quickly Consider searching using Google, ACES, issues? In general we want to search in a collection for a key
We've searched using trees and arrays
Tree implementation was quick: O(log n) worst/average? Arrays: access is O(1), search is slower
If we compare keys, log n is best for searching n elements
Lower bound is (log n), provable Hashing is O(1) on average, not a contradiction, why? Tries are O(1) worstcase!! (ignoring length of key)
CompSci 100E
22.1
From Google to Maps
If we wanted to write a search engine we'd need to access lots of pages and keep lots of data
Given a word, on what pages does it appear? This is a map of words>web pages
In general a map associates a key with a value
Look up the key in the map, get the value Google: key is word/words, value is list of web pages Anagram: key is string, value is words that are anagrams
Interface issues
Lookup a key, return boolean: in map or value: associated with the key (what if key not in map?) Insert a key/value pair into the map
22.2
CompSci 100E
Interface at work: MapDemo.java
Key is a string, Value is # occurrences Interface in code below shows how Map class works while (scanner.hasNext()) { String s = (String) scanner.next(); Counter c = (Counter) map.get(s);
if (c != null) c.increment(); else map.put(s, new Counter());
}
What clues are there for prototype of map.get and map.put? What if a key is not in map, what value returned? What kind of objects can be put in a map?
CompSci 100E 22.3
Accessing all values in a map (e.g., print)
Access every key in the map, then get the corresponding value
Get an iterator of the set of keys: keySet().iterator() For each key returned by this iterator call map.get(key) ...
Get an iterator over (key,value) pairs, there's a nested class called Map.Entry that the iterator returns, accessing the key and the value separately is then possible
To see all the pairs use entrySet().iterator()
CompSci 100E
22.4
External Iterator without generics
The Iterator interface accesses elements
Source of iterator makes a difference: cast required?
Iterator it = map.keySet().iterator(); while (it.hasHasNext()){ Object value = map.get(it.next()); } Iterator it2 = map.entrySet().iterator(); while (it2.hasNext()){ Map.Entry me = (Map.Entry) it.next(); Object value = me.getValue(); }
CompSci 100E
22.5
External Iterator with generics
Avoid Object, we know what we have a map of
Is the syntax worth it?
Iterator<String> it = map.keySet().iterator(); while (it.hasHasNext()){ Object value = map.get(it.next()); } Iterator<Map.Entry<String,Counter>> it2 = map.entrySet().iterator(); while (it2.hasNext()){ Map.Entry<String,Counter> me = it.next(); Object value = me.getValue(); }
CompSci 100E 22.6
Hashing: Log (10100) is a big number
Comparison based searches are too slow for lots of data
How many comparisons needed for a billion elements? What if one billion webpages indexed?
Hashing is a search method: average case O(1) search
A hash function generates the number from the key
Worst case is very bad, but in practice hashing is good Associate a number every with key, use the number to store the key o Like catalog in library, given book title, find the book Goal: Efficient to calculate Goal: Distributes keys evenly in hash table
CompSci 100E
22.7
Hashing details
There will be collisions, two keys will hash to the same value
0
1
2
3
n-1
Several ways to handle collisions, in general array/vector used
We must handle collisions, still have efficient search What about birthday "paradox": using birthday as hash function, will there be collisions in a room of 25 people? Linear probing, look in next spot if not found o Hash to index h, try h+1, h+2, ..., wrap at end o Clustering problems, deletion problems, growing problems Quadratic probing o Hash to index h, try h+12, h+22 , h+32 , ..., wrap at end o Fewer clustering problems Double hashing o Hash to index h, with another hash function to j o Try h, h+j, h+2j, ...
22.8
CompSci 100E
Chaining with hashing
With n buckets each bucket stores linked list
Compute hash value h, look up key in linked list table[h] Hopefully linked lists are short, searching is fast Unsuccessful searches often faster than successful o Empty linked lists searched more quickly than nonempty Potential problems?
Hash table details
Size of hash table should be a prime number Keep load factor small: number of keys/size of table On average, with reasonable load factor, search is O(1) What if load factor gets too high? Rehash or other method
22.9
CompSci 100E
Hashing problems
Linear probing, hash(x) = x, (mod tablesize)
Insert 24, 12, 45, 14, delete 24, insert 23 (where?) 12 24 45 2 3 14 4 5 6 7 8 9 10
0
1
Same numbers, use quadratic probing (clustering better?)
12 0 1 24 2 14 3 4 45 5 6 7 8 9 10
What about chaining, what happens?
CompSci 100E
22.10
What about hash functions
Hashing often done on strings, consider two alternatives
public static int hash(String s) { int k, total = 0; for(k=0; k < s.length(); k++){ t...