Assignments for CS 216, Fall 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 explanation see the handout on Moodle and the example 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 throw exceptions; instead they return null to indicate "failure"
null keys are allowed, but do not include test cases for this
create JUnit 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 class has only two data members (`key` and `value`) that can be accessed directly. 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, when used it needs to be written as `Entry<K, V>`, i.e. with explicit 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"`.

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 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 "dummies" are data members

use enhanced for-loop wherever possible

none of the methods throw exceptions; instead they return null to indicate "failure"

?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.

V get(K key)

Returns the value associated with the given key.

V remove(K key)

Removes/deletes the entry with the given key from the map and returns the entry's value.

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. Use enhanced for loop.

void rehash()

(private) Expands the map storage (after adding new entry) if size ≥ load_factor * capacity. Rehashes all the key/value pairs (cannot simply copy the entries to the same indices indices).
The effect of rehashing is to double the map capacity (twice as many buckets) and to rearrange the entries, as if someone collected all entries in left-to-right, top-to-bottom order and put them in an initially empty 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. it has no entries, but it does have buckets:
for LHashMap returns (letter E is placed 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 n buckets and assert that you got the correct string

avoid 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 from the first bucket to the last; 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.
Include test cases for the failing condition(s) of the iterator (recreate the map for different types of conditions.).

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

MyString otherCat = new MyString("4cat");
otherCat.hashCode()  will give 43

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" );

//
// LHashMapTest: At the end test for "fail" conditions for iterator.
//

CS 216
Data Structures and Algorithms

Assignment 4

Description

Testing

Implementation

The `Entry` Class

The `Map` Methods

Testing

What to turn in

CS 216 Data Structures and Algorithms

Assignment 4

Description

Testing

Implementation

The Entry Class

The Map Methods

Testing

What to turn in

CS 216
Data Structures and Algorithms

The `Entry` Class

The `Map` Methods