Question

Implement the remove() and the rehash() methods for the following externally chained hash table. Note you should rehash when "size > arraySize" at the start of the put() method. The new size of the arraySize should be "(2 * old array size) + 1"

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.Map;

public class ExternalChainingHashTable<K,V> {
private class Mapping {
private Mapping next;
private K key;
private V value;

private Mapping(K key, V value) {
this.key = key;
this.value = value;
}
}

private static final int GOOD_ARRAY_SIZE = 1021;
private int arraySize;
private int size;
private ArrayList<LinkedList<Mapping>> bucketArray;

public ExternalChainingHashTable(int initialArraySize) {
arraySize = initialArraySize;
bucketArray = new ArrayList<>(arraySize);

for (int i = 0; i < arraySize; i++) {
bucketArray.add(new LinkedList<Mapping>());
}
}

public ExternalChainingHashTable() {
this(GOOD_ARRAY_SIZE);
}

private int hash(K key) {
// We cannot assume that hashCode is positive, so we deal with
// the negative values by computing hc % N then adding N to ensure
// that result is positive and performing % N again to ensure it is in
// range
return ((key.hashCode() % arraySize) + arraySize) % arraySize;
}

public int getSize() {
return size;
}

public double getLoad() {
return (double)size / (double) arraySize;
}

/* Maps the specified key to the specified value in this hashtable. Neither
* the key nor the value can be null.
* The value can be retrieved by calling the get method with a key that is
* equal to the original key.
* Parameters:
* key - the hashtable key
* value - the value
* Returns:
* the previous value of the specified key in this hashtable, or null if
* it did not have one
*/
public V put(K key, V value) {
if (size > arraySize) {
rehash();
}

LinkedList<Mapping> bucket = bucketArray.get(hash(key));
for (Mapping m : bucket) {
if (m.key.equals((key))) {
V oldValue = m.value;
m.value = value;
return oldValue;
}
}
bucket.add(new Mapping(key, value));
size++;
return null;
}

/* Returns the value to which the specified key is mapped, or null if this
* map contains no mapping for the key.
* More formally, if this map contains a mapping from a key k to a value v
* such that (key.equals(k)), then this method returns v; otherwise it
* returns null. (There can be at most one such mapping.)
* Parameters:
* key - the key whose associated value is to be returned
* Returns:
* the value to which the specified key is mapped, or null if this map
* contains no mapping for the key
*/
public V get(K key) {
LinkedList<Mapping> bucket = bucketArray.get(hash(key));
for (Mapping m : bucket) {
if (m.key.equals((key))) {
return m.value;
}
}
return null;
}

/* Removes the key (and its corresponding value) from this hashtable. This
* method does nothing if the key is not in the hashtable.
* Parameters:
* key - the key that needs to be removed
* Returns:
* the value to which the key had been mapped in this hashtable, or null
* if the key did not have a mapping
*/
public V remove(K key) {
// WRITE CODE HERE

}

/* Increases the capacity of and internally reorganizes this hashtable, in
* order to accommodate and access its entries more efficiently. This method
* is called automatically when the number of keys in the hashtable exceeds
* this hashtable's capacity and load factor.
* Note you should rehash when "size > arraySize" at the start of the put()
* method.
* The new size of the arraySize should be "(2 * old array size) + 1"
*/
private void rehash() {
// WRITE CODE HERE

}
}

Answer 1

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.Map;

public class ExternalChainingHashTable<K, V> {
    private class Mapping {
        private K key;
        private V value;

        private Mapping(K key, V value) {
            this.key = key;
            this.value = value;
        }

        @Override
        public String toString() {
            return "(" + key + "," + value + ")";
        }
    }

    private static final int GOOD_ARRAY_SIZE = 1021;
    private int arraySize;
    private int size;
    private ArrayList<LinkedList<Mapping>> bucketArray;

    public ExternalChainingHashTable(int initialArraySize) {
        arraySize = initialArraySize;
        bucketArray = new ArrayList<>(arraySize);

        for (int i = 0; i < arraySize; i++) {
            bucketArray.add(new LinkedList<Mapping>());
        }
    }

    public ExternalChainingHashTable() {
        this(GOOD_ARRAY_SIZE);
    }

    private int hash(K key) {
        // We cannot assume that hashCode is positive, so we deal with
        // the negative values by computing hc % N then adding N to ensure
        // that result is positive and performing % N again to ensure it is in
        // range
        return ((key.hashCode() % arraySize) + arraySize) % arraySize;
    }

    public int getSize() {
        return size;
    }

    public double getLoad() {
        return (double) size / (double) arraySize;
    }

    /*
     * Maps the specified key to the specified value in this hashtable. Neither the
     * key nor the value can be null. The value can be retrieved by calling the get
     * method with a key that is equal to the original key. Parameters: key - the
     * hashtable key value - the value Returns: the previous value of the specified
     * key in this hashtable, or null if it did not have one
     */
    public V put(K key, V value) {
        if (size > arraySize) {
            rehash();
        }

        LinkedList<Mapping> bucket = bucketArray.get(hash(key));
        for (Mapping m : bucket) {
            if (m.key.equals((key))) {
                V oldValue = m.value;
                m.value = value;
                return oldValue;
            }
        }
        bucket.add(new Mapping(key, value));
        size++;
        return null;
    }

    /*
     * Returns the value to which the specified key is mapped, or null if this map
     * contains no mapping for the key. More formally, if this map contains a
     * mapping from a key k to a value v such that (key.equals(k)), then this method
     * returns v; otherwise it returns null. (There can be at most one such
     * mapping.) Parameters: key - the key whose associated value is to be returned
     * Returns: the value to which the specified key is mapped, or null if this map
     * contains no mapping for the key
     */
    public V get(K key) {
        LinkedList<Mapping> bucket = bucketArray.get(hash(key));
        for (Mapping m : bucket) {
            if (m.key.equals((key))) {
                return m.value;
            }
        }
        return null;
    }

    /*
     * Removes the key (and its corresponding value) from this hashtable. This
     * method does nothing if the key is not in the hashtable. Parameters: key - the
     * key that needs to be removed Returns: the value to which the key had been
     * mapped in this hashtable, or null if the key did not have a mapping
     */
    public V remove(K key) {
        LinkedList<Mapping> bucket = bucketArray.get(hash(key));
        V value = null;
        for (Mapping m : bucket) {
            if (m.key.equals((key))) {
                bucket.remove(m);
                value = m.value;
                break;
            }
        }
        return value;
    }

    /*
     * Increases the capacity of and internally reorganizes this hashtable, in order
     * to accommodate and access its entries more efficiently. This method is called
     * automatically when the number of keys in the hashtable exceeds this
     * hashtable's capacity and load factor. Note you should rehash when
     * "size > arraySize" at the start of the put() method. The new size of the
     * arraySize should be "(2 * old array size) + 1"
     */
    private void rehash() {
        ArrayList<LinkedList<Mapping>> olddata = bucketArray;
        
        arraySize = 2*arraySize + 1;
        bucketArray = new ArrayList<>(arraySize);
        
        // We again put all the data into new list
        for(LinkedList<Mapping> x: olddata) {
            for(Mapping m: x) {
                put(m.key, m.value);
            }
        }
        
        // size remains same.
    }
    
    public void print() {
        for(LinkedList<Mapping> x: bucketArray) {
            if(!x.isEmpty())
                System.out.println(x);
        }
        System.out.println();
    }
    
    public static void main(String args[]) {
        ExternalChainingHashTable<Integer, String> ec = new ExternalChainingHashTable<>();
        ec.put(1, "1");
        ec.put(2, "2");
        ec.put(3, "3");
        ec.put(4, "4");
        ec.put(1025, "10225");
        ec.put(1022, "1022");
        ec.put(1023, "1023");
        ec.print();
        
        ec.remove(1025);
        ec.print();
    }
}

**************************************************

Thanks for your question. We try our best to help you with detailed answers, But in any case, if you need any modification or have a query/issue with respect to above answer, Please ask that in the comment section. We will surely try to address your query ASAP and resolve the issue.

Please consider providing a thumbs up to this question if it helps you. by Doing that, You will help other students, who are facing similar issue.