CS323 - Homework 1

Hashing with Separate Chaining
- The lecture notes on Hashing using Separate Chaining to handle collision is here: click here
Project Assignment
- In this project, you must implement a hash table and take care of collisions using separate chaining
- The end product of this project is a Java class called HashListMap that implements a Map using hashing with a linked list in each hash bucket to handle collisions.

Program organization

We will implement the HashListMap as general as possible using interfaces (see the relevant material here: click here)

We will use the same interfaces shown in some CS323 lecture:

Map: click here

public interface Map { /** Returns the number of items in the map. */ public int size(); /** Returns whether the map is empty. */ public boolean isEmpty(); /** Puts a given key-value pair in the map, replacing a previous * one, if any, and returns the old value. */ public V put(K key, V value); /** Returns the value associated with a key. */ public V get(K key); /** Removes the key-value pair with a given key. */ public V remove(K key); }

Entry: click here

public interface Entry { /** Returns the key stored in this entry. */ public K getKey(); /** Returns the value stored in this entry. */ public V getValue(); }

You need to write a class that implements the classes above.

To help you get started, I have provided you with 2 partially written Java classes that implements the above interfaces:

HashListEntry.java (implments Entry)

public class HashListEntry<K, V> implements Entry<K, V> { public K key; public V value; public HashListEntry<K,V> prev; public HashListEntry<K,V> next; // *************************************************** // Constructor: // Initial the key and value variable using k and v // and set prev and next to null // *************************************************** public HashListEntry(K k, V v) { } // *************************************************** // getKey(): return the key in the entry // *************************************************** public K getKey() { } // *************************************************** // getKey(): return the value in the entry // *************************************************** public V getValue() { } public V setValue(V val) { V oldValue = value; value = val; // Update value return oldValue; // Return old value } public String toString() { return( "(" + key + "," + value + ")" ); } }

HashListMap.java (implements Map)

public class HashListMap<K, V> implements Map<K, V> { public HashListEntry<K,V>[] 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; ... // **************************************************************** // Todo: implement these 3 methods // // 1. insert() // 2. delete() // 3. findEntry() // // See project description for details // **************************************************************** // **************************************************************** // insert(bucketID, e): insert entry e in bucket[bucketID] // // Write this method // **************************************************************** public void insert(int bucketID, HashListEntry<K, V> e) { } // ***************************************************************** // delete(bucketID, e): delete entry e from bucket[bucketID] // // Write this method // ***************************************************************** public void delete(int bucketID, HashListEntry<K, V> p) { } // ********************************************************************* // findEntry(key): find entry for given key // // Return value: // // The reference to entry that contains the given key // If key is NOT found, return null // // Write this method // ********************************************************************* public HashListEntry<K,V> findEntry(K key) { } /* =========================================================== get(), put() and remove() are very easily implemented using findEntry() insert() delete() =========================================================== */ public V get(K k) { HashListEntry<K, V> e; e = findEntry(k); // Find entry for the key k if ( e != null ) { return e.getValue(); // return value } else { return null; // Key not found } } ... }

So in each of the provided file, there are a few methods missing. You must write those methods according to the specifications given in comment near the method definition.

By the way:

In each of the classes, I have written a toString() method that prints out the content of the object.
I will provide a test program for you to test your HashListMap program.
The test program uses these toString() methods to print out the entire content of the map.
So this addition will help you debug your methods

Postscript
- You must update the count of the number of entries stored in the hash table.
  You can choose to do it in any one of the methods... it's up to you. You can even make changes to the put() and remove() method.
- I'll let you decide how to do it.

Test program

I have provided a test program to help you test (and debug) your HashListMap class: click here

It does many insert, get and remove operations and print the map after each operation:

import java.util.*; public class MyTestMap { public static void main(String[] args) { int i; Integer x; String s; Map M = new HashListMap(4); M.put("a", 1); System.out.println("+(a,1): " + M); M.put("b", 5); System.out.println("+(b,5): " + M); .... x = M.get("d"); System.out.println("Value of d = "+((x==null)?"null":x)); x = M.get("e"); System.out.println("Value of e = "+((x==null)?"null":x)); .... M.remove("a"); System.out.println("-a: " + M); M.remove("a"); System.out.println("-a: " + M); .... }

A correct implementation of the HashListMap class will produce the following output:

cheung@compute(1137)> java MyTestMap +(a,1): {(a,1) } (1 entries) +(b,5): {[(b,5) (a,1) ] } (2 entries) +(c,6): {(c,6) [(b,5) (a,1) ] } (3 entries) +(d,8): {[(d,8) (c,6) ] [(b,5) (a,1) ] } (4 entries) *(d,3): {[(d,3) (c,6) ] [(b,5) (a,1) ] } (4 entries) +(e,4): {[(e,4) (d,3) (c,6) ] [(b,5) (a,1) ] } (5 entries) *(e,7): {[(e,7) (d,3) (c,6) ] [(b,5) (a,1) ] } (5 entries) +(f,9): {[(e,7) (d,3) (c,6) ] [(b,5) (a,1) ] (f,9) } (6 entries) +(g,2): {[(e,7) (d,3) (c,6) ] [(b,5) (a,1) ] [(g,2) (f,9) ] } (7 entries) Value of d = 3 Value of e = 7 Value of x = null -a: {[(e,7) (d,3) (c,6) ] (b,5) [(g,2) (f,9) ] } (6 entries) -a: {[(e,7) (d,3) (c,6) ] (b,5) [(g,2) (f,9) ] } (6 entries) -b: {[(e,7) (d,3) (c,6) ] [(g,2) (f,9) ] } (5 entries) -b: {[(e,7) (d,3) (c,6) ] [(g,2) (f,9) ] } (5 entries) -c: {[(e,7) (d,3) ] [(g,2) (f,9) ] } (4 entries) -d: {(e,7) [(g,2) (f,9) ] } (3 entries) -g: {(e,7) (f,9) } (2 entries)

Handouts for this assignment

Here is the list of all provided Java files mentioned in this handout:

Entry.java: click here (interface - do not change this file)
Map.java: click here (interface - do not change this file)
HashListEntry.java: click here (class that implements the Entry interface)
HashListMap.java: click here (class that implements the Map interface)
MyTestMap.java: click here (Test program - you may change/add more statements to do more thorough testing)

Turnin

Turn in your HashListEntry.java and HashListMap.java program files with the following commands:

/home/cs323000/turnin HashListMap.java pj1 /home/cs323000/turnin HashListEntry.java pj1a

Note:

If you work on a project on your laptop, you must do the following to turn in your project:

Upload your programs into your cs323 project directory on Emory
Login to a machine in the MathCS lab (e.g. lab0z)
Change directory to the directory where you have uploaded your files.
Then run the turnin commands given above.

Unlike many other professors, I do not go to students' directories to find stuff.
I rather have them put the files securely into the grader account.
That way I find out who has turned in stuff and who has not easily (look in one place rather than sillion of places).