Implementing a map using a hash table

Intro

Presentation:

I will first show an implementation of a map containing entries of the form:
Then I will convert the implementation into a parameterized class

Also:

Unlike Goodrich's book, I will not use an interface for Entry
I will use a class instead....
That will cut away one level of abstraction
(Try to keep things simple).

Programming note:

In real life programs, you should make all instance variables in a class private
However, my programs are for demonstration purpose
Fact:

Representing the entries of a map

The Entry class:

public class Entry { public String key; // String typed key (for now) public Integer value; // Integer typed value (for now) /** Constructor */ public Entry( String k, Integer v) { key = k; value = v; } /** Returns the key stored in this entry. */ public String getKey() { return key; // You would need this when using private variables } /** Returns the value stored in this entry. */ public Integer getValue() { return value; } public Integer setValue(Integer val) { Integer oldValue = value; value = val; // Update value return oldValue; // Return old value } }

Variables used to make a Map data structure using Hashing

Components of hashing:

Variables to represent the hash table (which is an array of entries):

public Entry[] bucket; // The hash table (buckets) public int capacity; // capacity == bucket.length public int NItems; // NItems = # entries in hash table

Variables to represent the hash function

Hash function consists of 2 parts:

Hash code:

Remember that we are using:

String key

The commonly used hash code for String is:

polynomial hash code

We must write one... But... fortunately, the Java String class has one built in: ( click here)

public int hashCode() Returns a hash code for this string. The hash code for a String object is computed as s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

(These Java people must have read the Goodman's book :))

Anyway, we will use the one from the Java String class

If it did not have one, we could write one easily:

public int hashCode(String s) { int sum = 0; for (i = 0; i < s.length(); i++) { c = s.charAt(i); // c = next character sum = (int) c + 31*sum; } return(sum); }

Compression function:

We will use MAD (Multiple, Add, Divide)

Variables needed to store MAD function:

public int MAD_a; // The "a" in [(a * HashCode + b) % p ] % N public int MAD_b; // The "b" in [(a * HashCode + b) % p ] % N public int MAD_p; // The "p" in [(a * HashCode + b) % p ] % N

Constructor(s): set up variables in the hash table

Parameters to create a hash table (used to represent a Map):

Capacity = number of entries in the array

p = the prime number used in the MAD compression function

Recall that:

a = some (random) integer between [1 .. (p-1)] b = some (random) integer between [0 .. (p-1)]

So: a and b are not parameters

The most general constructor:

public class HashMap { public Entry[] bucket; // The hash table (buckets) public int capacity; // capacity == bucket.length public int NItems; // NItems = # entries in hash table public int MAD_p; public int MAD_a; public int MAD_b; /* =============================================================== General Constructor: initialize prime number p Create an array (bucket) of given size =============================================================== */ public HashMap(int p, int MapArraySize) { capacity = MapArraySize; bucket = new Entry[ capacity ]; // Create the array ! NItems = 0; java.util.Random rand = new java.util.Random(); // Use to generate random numbers... MAD_p = p; // Prime number in MAD MAD_a = rand.nextInt(MAD_p-1) + 1; // Multiplier in MAD MAD_b = rand.nextInt(MAD_p); // Shift amount in MAD } ...... }

A convenient constructor if the user don't have a prime number handy:

/* =============================================================== Common Constructor: pick the default prime number 109345121 Create an array (bucket) of given size =============================================================== */ public HashMap(int MapArraySize) { this( 109345121, MapArraySize ); // Calls general constructor }

We also provide a default constructor for the super-lazy users:

public HashMap( ) // No parameters ! { this( 109345121, 1000 ); // Default array size = 1000 }

The HashMap class so far:

public class HashMap { public Entry[] bucket; // The hash table (buckets) public int capacity; // capacity == bucket.length public int NItems; // NItems = # entries in hash table public int MAD_p; public int MAD_a; public int MAD_b; /* =============================================================== General Constructor: initialize prime number p Create an array (bucket) of given size =============================================================== */ public HashMap(int p, int MapArraySize) { capacity = MapArraySize; bucket = new Entry[ capacity ]; NItems = 0; java.util.Random rand = new java.util.Random(); MAD_p = p; // Prime number in MAD MAD_a = rand.nextInt(MAD_p-1) + 1; // Multiplier in MAD MAD_b = rand.nextInt(MAD_p); // Shift amount in MAD } /* =============================================================== Common Constructor: pick the default prime number 109345121 Create an array (bucket) of given size =============================================================== */ public HashMap(int MapArraySize) { this( 109345121, MapArraySize ); // Calls general constructor } public HashMap() { this( 109345121, 1000 ); // Default array size = 1000 } ...... }

The Hash Function

Recall that:

Hash Function:

/* =============================================================== Hash function: 1. uses the Hash Code inside the String class 2. uses the MAD compression function hash index = [ (a*HashCode + b) % p ] % N =============================================================== */ public int hashValue(String key) { int x = key.hashCode(); // String has a built-in hashCode() !!! return (int) ( ( Math.abs( MAD_a*x + MAD_b ) % MAD_p ) % capacity ); }

A note before discussing get(), put() and remove() methods

Observation:

The first step of the get(), put() and remove() methods is:
Get(key k) must find the entry for given key k to return its value
Put(key k) must find the entry for given key k to determine whether it should insert (a new entry) or update (an existing entry)
Remove(key k) must find the entry for given key k to delete it....

findEntry(key k):

To avoid repeating the code for finding entries, we will write one (more complex) findEntry() help function that can be used by all 3 methods (get(), put() and remove() )

The get() method: lookup a value using a key

get() method:

/* =============================================== The entries are of the format: String key, Integer value So the return value is: Integer ! =============================================== */ public Integer get(String k) { int found = findEntry(k); // Find the array index for the key k // If found > 0, index_for_key is the index if ( found > 0 ) { // Found the key in the hash table return bucket[index_for_key].getValue(); // return value } else { return null; // Key not found } }

Note:

The findEntry() help function

Help function: findEntry(String k)

Task of the findEntry(String k) method:

Determine is the key k is found in the Map (Hash table)

Important reminder:

Each of the methods put() (insert), get() (lookup) and remove() (delete) will need to use findEntry() to find a key first !
In the put() method, if the key is not found (i.e., put will insert a new entry) and we encountered some special EMPTY markers in the search, we must use the first AVAILABLE location in the put() (insert) operation.
See: click here

Return values:

findEntry(k) returns 1 if: the key k was found in the Map (Hash table) In this case, the (help) variable index_for_key is set to the array index where key k was found
findEntry(k) returns 0 if: the key k was NOT found in the Map (Hash table) In this case, the (help) variable index_for_key is set to the array index where key k can be stored
findEntry(k) returns -1 when there is an error.

Pseudo code:

int findEntry(String key) // I use key instead of k to make the key explicit { if ( key == null ) return ERROR; i = hashValue( key ); // Start the search at index i while ( search did not wrap around ) { if ( bucket[i] contains an entry ) { // 2 possibilities: // 1. entry has a value (key, value) // 2. entry contains special EMPTY marker (see: click here) if ( bucket[i] == EMPTY Marker ) // Entry contains the special EMPTY marker { // entry was deleted previously Remember the location of the FIRST special EMPTY marker ********* // For the reason, see: click here i = (i + 1) % capacity; // Continue search } else ( bucket[i].key == key ) // FOUND the key !!! { return FOUND ; (and location i contains the key !) ******** } } else // Search reach a HOLE -> key not found -- STOP { return NOT FOUND ; (and location i can be used to STORE the key !) ******** } } return NOT FOUND; // Search wrapped around --> not found ! **** This case can be a big problem: the hash table may be FULL **** We will add code to make sure the hash table will never fill up later }

Java implementation:

/* ==================================================================== findEntry(key): find index of the array for given key Return value: 1 ==> key is found in the hash table Set index_for_key such that: Entry[index_for_key].key == key 0 ==> key is NOT found Entry[index_for_key] is where you can STORE the key ==================================================================== */ public int findEntry(String key) { int i; int start; if ( key == null ) { index_for_key = -1; // Error return ( -1 ); // Not found } i = hashValue(key); // Start location to look for key start = i; // Remember the start location (to detect wrap around) index_for_key = -1; // Flag "no empty slow found" condition. do { Entry e; e = bucket[i]; // Testing bucket[i]... if ( e != null ) { // bucket[i] contains something... // Possibilities: // 1. the special EMPTY marker --> remember FIRST marker and // go to next entry // 2. contains the search key --> return FOUND // 3. contains some other key --> go to next entry if ( e == AVAILABLE ) { // entry in bucket was deleted if ( index_for_key < 0 ) index_for_key = i; // remember the FIRST available slot } else if ( key.equals(e.getKey()) ) // we have found our key { index_for_key = i; return 1; // key found !! } i = (i + 1) % capacity; // Check the next slot... if any } else { /* -------------------------------------------------- bucket[i] contains NULL: chain is broken We know the key is not in hash table -------------------------------------------------- */ if ( index_for_key < 0 ) // Did we found an EMPTY marker ? index_for_key = i; // No --> insert key here if needed return(0); // Return "not found" indication } } while ( i != start ); // Stop when you wrap around return 0; // Not found (wrapped around...) }

The put() method: insert/update an entry using a key

put() method is easy using the findEntry() help function:

public Integer put (String key, int value) { int found = findEntry(key); //find the appropriate spot for this entry if ( found > 0 ) // key found ===> update value { // Note: // The variable index_for_key is set to the bucket containing the key // i.e.: bucket[index_for_key].key == key Integer oldValue = bucket[index_for_key].setValue(value);// set new value return ( oldValue ); // Return old value } /* =============================================================== Key not found ==> Insert (key, value) in bucket[index_for_key] =============================================================== */ if ( index_for_key >= 0 ) { bucket[index_for_key] = new Entry(key, value); // Insert !!! NItems++; // One more entry... } else { // Hash table is FULL !!! System.out.println("ERROR: Hash Table is FULL !!!"); } return null; // there was no previous value }

The remove() method: delete an entry using a key

remove() is also very easy using the findEntry() help function:

public Integer remove (String key) { int found = findEntry(key); // find this key first if ( found == 0 ) // Not found.... return null; // nothing to remove **** If execution reach here, then key was found ===> Delete the entry ! // Note: // The variable index_for_key is set to the bucket containing the key // i.e.: bucket[index_for_key].key == key Integer toReturn = bucket[index_for_key].getValue(); // Remember old value bucket[index_for_key] = AVAILABLE; // mark this slot as deactivated NItems--; // One less entry... return toReturn; // Return old value }

The complete implementation of HashMap
- I have re-written Goodrich's implementation completely....
  Here is my own HashMap in Java.
- Example Program: (Demo above code)
  - Entry.java Prog file: click here
  - HashMap.java Prog file: click here
  - MyTestMap.java Test Prog file: click here (test get, put, remove)
  - TestMap1.java Test Prog file: click here (the word counting program, but uses own HashMap)
  How to run the program:

Value-added methods: keySet()

ketSet():
Sub-Problem that we need to solve:
I.e.: We must traverse all elements in an array !!! (which is easy to do....)

The keySet() method:

public Collection keySet() { LinkedList r = new LinkedList(); // One of the classes that implements // "Iterable" is LinkedList for ( int i = 0; i < bucket.length; i++ ) { Entry e; e = bucket[i]; if ( (e != null) && (e != AVAILABLE) ) { // e is a valid entry r.add( e.key ); } } return(r); }

Note: