Adding deletion to hashtables

Author: cutajarj

src/main/java/com/packt/datastructuresandalg/lesson3/activity/openaddressing/OpenAddrHashTable.java

@@ -18,6 +18,9 @@ public OpenAddrHashTable(int capacity, HashProvider<K> hashProvider) {
     public void put(K key, V value) {
     }
 
+    public void remove(K key) {
+    }
+
     public Optional<V> get(K key) {
         return Optional.empty();
     }

src/main/java/com/packt/datastructuresandalg/lesson3/activity/openaddressing/solution/OpenAddrHashTable.java

@@ -2,39 +2,49 @@
 
 import com.packt.datastructuresandalg.lesson3.hashtable.HashProvider;
 import com.packt.datastructuresandalg.lesson3.hashtable.HashTable;
-import com.packt.datastructuresandalg.lesson3.hashtable.Pair;
 
 import java.util.Optional;
 
 public class OpenAddrHashTable<K, V> implements HashTable<K, V> {
     private final HashProvider<K> hashProvider;
-    private Pair<K, V>[] array;
+    private OpenAddrPair<K, V>[] array;
 
     public OpenAddrHashTable(int capacity, HashProvider<K> hashProvider) {
-        array = new Pair[capacity];
+        array = new OpenAddrPair[capacity];
         this.hashProvider = hashProvider;
     }
 
     public void put(K key, V value) {
         int s = array.length;
         int hashValue = hashProvider.hashKey(key, s);
         int i = 0;
-        while (i < s && array[(hashValue + i) % s] != null)
+        while (i < s && array[(hashValue + i) % s] != null &&
+                !array[(hashValue + i) % s].isDeleted())
             i++;
-        if (i < s) array[(hashValue + i) % s] = new Pair<>(key, value);
+        if (i < s) array[(hashValue + i) % s] = new OpenAddrPair<>(key, value);
     }
 
-    public Optional<V> get(K key) {
+    private int searchPosition(K key) {
         int s = array.length;
         int hashValue = hashProvider.hashKey(key, s);
         int i = 0;
         while (i < s &&
                 array[(hashValue + i) % s] != null &&
                 !array[(hashValue + i) % s].getKey().equals(key))
             i++;
+        return (hashValue + i) % s;
+    }
+
+    public Optional<V> get(K key) {
+        return Optional.ofNullable(array[searchPosition(key)])
+                .filter(kv -> !kv.isDeleted())
+                .filter(kv -> kv.getKey().equals(key))
+                .map(OpenAddrPair::getValue);
+    }
 
-        return Optional.ofNullable(array[(hashValue + i) % s])
-                .filter(kv -> kv.getKey().equals(key)).map(Pair::getValue);
+    public void remove(K key) {
+        Optional.ofNullable(array[searchPosition(key)])
+                .ifPresent(kv -> kv.setDeleted(true));
     }
 
 }

src/main/java/com/packt/datastructuresandalg/lesson3/activity/openaddressing/solution/OpenAddrPair.java

@@ -0,0 +1,29 @@
+package com.packt.datastructuresandalg.lesson3.activity.openaddressing.solution;
+
+public class OpenAddrPair<K, V> {
+    private final K key;
+    private final V value;
+    private boolean deleted;
+
+    public OpenAddrPair(K key, V value) {
+        this.key = key;
+        this.value = value;
+        this.deleted = false;
+    }
+
+    public K getKey() {
+        return key;
+    }
+
+    public V getValue() {
+        return value;
+    }
+
+    public boolean isDeleted() {
+        return deleted;
+    }
+
+    public void setDeleted(boolean deleted) {
+        this.deleted = deleted;
+    }
+}

src/main/java/com/packt/datastructuresandalg/lesson3/hashtable/ChainedHashTable.java

@@ -26,6 +26,11 @@ public Optional<V> get(K key) {
                 .map(Pair::getValue);
     }
 
+    public void remove(K key) {
+        int hashValue = hashProvider.hashKey(key, array.length);
+        array[hashValue].removeIf(p -> p.getKey().equals(key));
+    }
+
     public static void main(String args[]) {
         ChainedHashTable<Integer, String> chainedHashTable = new ChainedHashTable<>(10, new RemainderHashing());
         chainedHashTable.put(12,"Isabel");
@@ -42,5 +47,7 @@ public static void main(String args[]) {
         System.out.println(chainedHashTable.get(31));
         System.out.println(chainedHashTable.get(42));
         System.out.println(chainedHashTable.get(45));
+        chainedHashTable.remove(31);
+        System.out.println(chainedHashTable.get(31));
     }
 }

src/main/java/com/packt/datastructuresandalg/lesson3/hashtable/HashTable.java

@@ -6,4 +6,6 @@ public interface HashTable<K,V> {
     void put(K key,V value);
 
     Optional<V> get(K key);
+
+    void remove(K key);
 }

src/test/java/com/packt/datastructuresandalg/lesson3/activity/openaddressing/OpenAddrHashTableTest.java

@@ -34,6 +34,26 @@ public void testItemOnOccupiedSlotHashTable() {
         assertEquals(Optional.of("Test6"), hashTable.get(6));
     }
 
+    public void testGetItemAfterRemove() {
+        OpenAddrHashTable<Integer, String> hashTable = new OpenAddrHashTable<>(10, new RemainderHashing());
+        hashTable.put(5, "Test5");
+        hashTable.put(15, "Test15");
+        hashTable.put(6, "Test6");
+        hashTable.remove(6);
+        assertEquals(Optional.empty(), hashTable.get(6));
+    }
+
+    public void testInsertItemAfterRemove() {
+        OpenAddrHashTable<Integer, String> hashTable = new OpenAddrHashTable<>(10, new RemainderHashing());
+        hashTable.put(5, "Test5");
+        hashTable.put(15, "Test15");
+        hashTable.put(6, "Test6");
+        hashTable.remove(6);
+        hashTable.put(25, "Test25");
+        assertEquals(Optional.of("Test25"), hashTable.get(25));
+    }
+
+
     public void testItemWrapsAroundHashTable() {
         OpenAddrHashTable<Integer, String> hashTable = new OpenAddrHashTable<>(10, new RemainderHashing());
         hashTable.put(8, "Test8");
@@ -55,6 +75,24 @@ public void testItemWrapsAroundHashTable() {
         assertEquals(Optional.empty(), hashTable.get(58));
     }
 
+    public void testRemoveItemWrapsAroundHashTable() {
+        OpenAddrHashTable<Integer, String> hashTable = new OpenAddrHashTable<>(10, new RemainderHashing());
+        hashTable.put(8, "Test8");
+        hashTable.put(18, "Test18");
+        hashTable.put(28, "Test28");
+        hashTable.put(38, "Test38");
+        hashTable.put(48, "Test48");
+        hashTable.put(9, "Test9");
+        hashTable.put(19, "Test19");
+        hashTable.put(0, "Test0");
+        hashTable.remove(9);
+        hashTable.put(58, "Test58");
+        assertEquals(Optional.empty(), hashTable.get(9));
+        assertEquals(Optional.of("Test0"), hashTable.get(0));
+        assertEquals(Optional.of("Test58"), hashTable.get(58));
+    }
+
+
     public void testSearchItemOnFullHashTable() {
         OpenAddrHashTable<Integer, String> hashTable = new OpenAddrHashTable<>(10, new RemainderHashing());
         hashTable.put(2, "Test2");