Assignments for CS 216, Spring 2024

Description

In this assignment you will implement the HashMap data structure. The HashMap can be viewed as a generalization of the primitive array or ArrayList. We still use indices to store data in the HashMap, but here the indices do not need to be sequential, and in fact, the indices do not need to be integers.

For a detailed example see here:

Hash Map Example

Quick summary:

Inserting in a HashMap
Calculate the bucket index i where the item would have been inserted:

Chaining: search the list/bucket for an entry with the given key -- if found, replace the value, otherwise add a new entry

Linear Probing: search the buckets with indices i, i+1, i+2, ... until either an entry with the key is found (replace value) or an Empty marker is found (add a new entry in the cell that has the first Deleted marker encountered during the search)

Searching in a HashMap
Calculate the bucket index i where the item would have been inserted:

Chaining: search the list/bucket for an entry with the given key

Linear Probing: search the buckets with indices i, i+1, i+2, ... until either an entry with the key is found or an Empty marker is found

Deleting from a HashMap
Calculate the bucket index i where the item would have been inserted:

Chaining: search the list/bucket for an entry with the given key -- if found, remove the entry from the list/bucket; use while loop with iterator

Linear Probing: search the buckets with indices i, i+1, i+2, ... until either an entry with the key is found or an Empty marker is found; if the item is found, put in the cell the Deleted marker (why?)

Testing

See Section "Testing" at the very bottom.

Implementation

Create two separate projects called CHashMap and LHashMap that implement the methods given below using the Chaining and Linear Probing collision resolution schemes:

create classes CHashMap and LHashMap, respectively
LHashMap and CHashMap must keep track of the size (i.e. number of entries)
none of the methods will throw exceptions; instead they will return null
it is assumed for this assignment that the user will not call a method with null key
create JUnit4 testers CHashMapTest and LHashMapTest, respectively

Keep in mind that you will need to:

implement a new class called Entry that stores the original key and value provided by the user
the HashMap is parameterized on two types HashMap<K, V>, i.e. similar to LinkedList, but with two letters

The `Entry` Class
This is a with only two data members (`key` and `value`). This class is loosely an analog of `Node` for `LinkedList`. For this assignment `Entry` will be an external class, i.e. in its own file. It is a generic class on two types `<K, V>` (for comparison, the `LinkedList` was generic on only one type `<E>`). Since the class is external you need to write `Entry<K, V>`, i.e. explicitly mention the generic type `K` and `V`, unlike `Node` which was internal, so the generic type `E` was implicit and was not written. The `Entry` class has method `toString` that returns the contents in this format `cat:4` assuming the entry has `key "cat"` and `value "4"` (just plus the two things with the ":")

Setup

Use a primitive array for the buckets:
data member section constructor
LHashMap
Entry<K, V>[] _array-name_;
_array-name_ = (Entry<K, V>[]) new Entry[ ... ];
CHashMap
LinkedList<Entry<K, V>>[] _array-name_;
_array-name_ = (LinkedList<Entry<K, V>>[]) new LinkedList[ ... ];
Each map needs to have a data member to keep track of the size (i.e. number of entries)

LHashMap only: needs to have two Entry data members to represent the Empty and Deleted buckets; this is similar to the dummy node in the LinkedList, but now the "dummys" are data members

must use enhanced for-loop wherever possible

?HashMap(int initialCapacity, double loadFactor)

Creates a map with the given capacity and load factor; make sure to put empty buckets in the hash map container (empty lists for Chaining, Empty marker for Linear Probing).
The loadFactor is a number in [0..1]. Initially, just assign it and ignore it.

boolean isEmpty()

Determines if the map is empty; this method must run in time O(1), i.e. no loops.

int size()

Returns the number of (key, value) pairs stored in this map. This method must run in time O(1), i.e. no loops. The methods put and remove should keep track of the current size.

V put(K key, V value)

Puts the given value under the given key and returns the old value associated with this key (or null if the key was not in the map).

V get(K key)

Returns the value associated with the given key (or null if the key was not in the map).

V remove(K key)

Removes/deletes the entry with the given key from the map and returns the value associated with this key (or null if the key was not in the map).

void clear()

clears the map

boolean containsKey(K key)

Determines if the map contains an element with the given key/index.

boolean containsValue(V value)

Determines if the map contains the given value.
For LHashMap implement this using the iterator over the values in the map. This method will indirectly test the iterator.

void rehash()

(private) Expands the map storage (after adding *new* entry) if size ≥ load_factor * capacity. Rehashes all the key/value pairs (use the method put; do not simply copy entries).

After rehashing, the map capacity has doubled (twice as many buckets) and the contents is arranged as if someone collected all entries in left-to-right, top-to-bottom order and put them in an initially empty map.

This method is called only when a brand new package is entered in the map.

String toString()

Returns a string representation of the map. Here are examples of maps with capacity 10 -- one map has 4 entries and the other map is empty, i.e. has no entries:
for LHashMap returns (letter E is written for Empty marker, letter D for Deleted marker)
4:[D E 76544632:mickey 14742300:donald D 67587658:minnie E E D 22571632:tom]
0:[E E E E E E] (for empty map)
for CHashMap returns:
4:[[] [] [] [] [76544632:mickey 14742300:donald 67587658:minnie] [] [] [22571632:tom] [] []]
0:[[] [] [] [] [] [] [] [] [] []] (for empty map)
the first number is the size of the map, i.e. number of entries, not number of buckets

in CHashMapTest and LHashMapTest, respectively, create an empty map of 10 buckets (default) and assert that you got the correct string

no if statements and only one loop is needed in each case, since LinkedList and Entry have method toString, so you can simply write:

LHashMap: str = str + entry
CHashMap: str = str + list_of_entries
in CHashMap there will be commas, so to remove at the end write:

str = str.replaceAll(",", "")

Iterator<V> iterator()

Returns an iterator over the values stored in this map (in no particular order); operation remove is not implemented.
You are only expected to implement iterator for LHashMap class. This will be similar to the Stack iterator, but hasNext() will have a loop.
No test cases required. Tested implicitly.

Testing

For testing:

the tester should have only one @Test method; there will not be empty, single multi maps
inside the tester method create only one map as shown in the last bullet below and then start inserting, retrieving, removing; for each operation assert the expected result and the toString
download and use the modified String class MyString.java for the keys

the class MyString overrides the hashCode method so that it returns the length of the string:

MyString myCat = new MyString("cat");
myCat.hashCode()     will give 3: nice and simple

String javaCat = "cat";
javaCat.hashCode()   will give 98262: not simple

copy the following convenience method in the Tester classes:

// shortcut for making MyString objects
// * instead of:   myMap.put( new MyString("cat"), 4 );
// * can  write:   myMap.put( ms("cat"), 4 );
private static MyString ms(String str)
{
    return new MyString(str);
}

In the Tester classes you can then write:

?HashMap<MyString, Integer>  map = new ?HashMap<MyString, Integer>();
assertEquals( map.toString(), "the expected contents" );

assertTrue( map.put( ms("january"), 31 ) == ??? );
assertEquals( map.toString(), "the expected contents" );
...
assertTrue( map.remove( ms("january") == ??? );
assertEquals( map.toString(), "the expected contents" );
...
assertTrue( map.put( ms("april"), 30 ) == ??? );
assertEquals( map.toString(), "the expected contents" );
...
assertTrue( map.remove( ms("april") == ??? );
assertEquals( map.toString(), "the expected contents" );

CS 216
Data Structures

Assignment 4

Description

Testing

Implementation

The `Entry` Class

The `Map` Methods

Testing

What to turn in

CS 216 Data Structures

Assignment 4

Description

Testing

Implementation

The Entry Class

The Map Methods

Testing

What to turn in

CS 216
Data Structures

The `Entry` Class

The `Map` Methods