Dictionary based on arrays. Hashing and Hash tables. Trade-offs. Hashing: Generalizing the index

Transcription

1 Dictionary based on arrays Hashing and Hash tables Suppose have a dictionary with small integer keys, in range -. Can use an array containing values, with key as index. private Object[] thedictionary = new Object[]; we retrieve the value associated with a particular key by simply indexing into the array: //require: <= key && key <= public Element get (int key) { return (Element) thedictionary[key]; Plusses Trade-offs Accessing the dictionary requires only constant time, rather than linear or logarithmic time required by lists or binary searches. Minuses set of possible keys is rarely limited to a small range of integers or even integers. When keys are integers, set of possible values is typically large, such as social security numbers. Keys are often character strings (names, for instance) or more general objects. Hashing: Generalizing the index We can use the idea of indexing an array if we convert a key to an array index. a hash function. A hash function takes a key as argument, and returns an array index as result. If thedictionary is the name of the array, a hash function can be specified as follows: //ensure: <= result && result < thedictionary.length int hash (Key key) To locate an item in the dictionary, the hash function is applied to the key to obtain the array index: public Element valueof (Key key) { return thedictionary[hash(key)];

2 Hashing Hashing goal is efficiency: hash function must be easy to compute. For example, if keys are social security numbers: keys hash function int hash (int key) { return key % ; Hashing Problems: Which hashing function to use Collision (not perfect hashing). the hash function will map many different keys to the same index. Load factor: Hashing Requirements for a hashing function: i. Easy to compute. ii. Evenly distributed key values. iii. Must have equal keys to hash to same index The goal here is to reduce the number of collisions. Distribution of collisions in dictionary

3 Hashing Need to know something about the expected keys. For instance, if keys are seven digit numbers and the index set is -, a reasonable hash function simply takes the high-order three digits: int hash (int key) { return key / ; However, if the seven digit keys are local telephone numbers, then this is clearly not a good approach. We are in fact selecting the local exchange, of which there will be very few. Object s hash method The Java class Object defines a method hashcode, specified as public int hashcode(); It can be used to build a hash function. Thus a hash function for the array thedictionary might be written: int hash (Key key) { return Math.abs(key.hashCode())%theDictionary.length; Object s hash method Canonical Java class definition Java Objects are expected to use built-in hash functions or re-define it if you redefine the equals. the method hashcode as defined in the class Object is only guaranteed to produce equal values for identical arguments. That is, if a == b, then a.hashcode() == b.hashcode() this is a very strong requirement, atypical for most of our applications We usually redefine equals on objects Thus, the rd requirement of a hashing function, equals must hash to equals, will require that we redefine Java s hash function for every class where we redefine equals. Thus a well define class must include: public boolean equals(object obj){ public int hashcode(){ public Object clone(){ public String tostring(){

4 Hashing functions Casting to an integer Polynomial hash code Folding shifting if we attempt to insert an element in the dictionary and the location returned by the hash function is already occupied, search the array for the next unoccupied location. //Add a key-value pair, given that the dictionary is not full. public add (Key key, Element value) { int index = hash(key); // Find the next available position while (thedictionary[index]!= null) index = (index+)%thedictionary.length; thedictionary[index] = new KeyValuePair(key, value); Elements with keys,,,,, are added in that order Elements with keys,,,,, are added in that order

5 Elements with keys,,,,, are added in that order Elements with keys,,,,, are added in that order Elements with keys,,,,, are added in that order Elements with keys,,,,, are added in that order

6 To locate a key, start at hash location and sequentially search array. public Element valueof (Key key) { int index = hash(key); while (thedictionary[index]!= null &&!thedictionary[index].key().equals(key)) index = (index+)%thedictionary.length; if (thedictionary[index] == null) return null; else return thedictionary[index].value(); If key searched for is not in dictionary, finds empty element and return null. Algorithm assume array is not full. Problems with deletion. Items are deleted by replacing it with a null Might find null before finding chain element. deleted element can be left in table and marked deleted. over time the table becomes cluttered with deleted elements. the deleted elements will need to be removed, remaining elements must repositioned in the table. This is referred to as rehashing, and is a relatively expensive operation. Handling Collisions: separate chaining Implements the dictionary as an array of lists. An element is added by appending it to the list specified by the hash function. time required to add an element will be constant, if the list append operation is constant, time required to locate a key depends only on number of items hashed to same location. Deletion presents no particular problem. Load factor the more elements a table contains, the more the look up method exhibits linear behavior. load factor = n/ array size. With open chaining, load factor is for an empty table, for a completely full table. With separate chaining, load factor can be larger than.

7 Load factor Use smaller number of buckets, but at the risk to increment the number of collisions, thus length of maximum list will grow. Given m keys from n slots, the load factor is m/n. At it increases, we ll find less empty buckets. Probability of empty buckets : e m/n With m/n ==, % buckets will be empty With m/n ==,.% will be empty. Assuming a uniform distribution The probability that k out m keys will fall into a particular bucket of a table with n entries: (m/n) k e m/n k! For a given load factor, m/n, expected number of nodes examined for a successful search is approximately + (m/n)/ For an unsuccessful search, is (m/n)/ With linear probing, Load factor if the load factor is. i.e., the table is half full locating a key in the table requires on average examining only about. cells. Inserting an element or determining that an element is not in the table, requires only about. probes. As the load factor approaches, performance degenerates. With load factor of., roughly cells need to be examined to locate an item linear probing is acceptable if load factor remains small less than.. easy to achieve for a stable dictionary whose size can be given a priori. Load factor Not easy to accomplish with a dynamic table, with many additions and deletions. Then, must be prepared to increase table size when table becomes too full. However, since the hash function depends on the number of elements in the table, increasing table size requires repositioning of all elements in the table that is, rehashing. With separate chaining, a load factor of. is generally considered acceptable. Locating a key requires about. problems with a load factor of..

8 Java s hashing tables Java defines interface map public V put (K key, V value) Add a key-value pair to the dictionary, or replaces the value if an entry with the specified key is already in the dictionary. Returns the value previously associated with the key, or null if the key was not previously in the map. public V get (K key) Retrieve a value associated with a specified key. public V remove (K key) Remove an item with the specified key. Returns the value associated with the key, or null if the key was not in the dictionary. HashMap HashMap is a concrete class that implements Map. The table of key-value pairs is implemented with a separate-chaining approach. The hash function is based on object s own hashcode plus a supplemental hash function, which defends against poor quality hash functions. Keys must implement hashcode and equals in a consistent way. That is, if k and k are keys and k.equals(k), then it must be the case that k.hashcode() == k.hashcode(). The class HashMap provides several constructors. One version allows specification of the initial array size (initialcapacity) and the maximum acceptable load factor. public HashMap (int initialcapacity, float loadfactor); HashMap Performance is improved if initialcapacity is a prime number. The specified load factor should be between and. If load factor of the table is exceeded, a new array is allocated, and elements are rehashed into it. size of the new array is twice the size of the previous, plus one. A second constructor requires only the initial capacity be specified: public HashMap (int initialcapacity); A default load factor of. is used in this case. Finally, a Hashtable with default initial capacity of items can be created by using a constructor with no arguments