fix: Update hash_map_open_addressing.java (#727)

* FixBug:Update hash_map_open_addressing.java

1. put keyA, hashFunc 在位置 5
2 put key B, hashFunc 在位置  5. 和 A冲突，插入位置6
3. remove keyA,位置5removed
4. put keyB, hashFunc 在位置  5. 没有冲突，插入位置5
5. remove keyB, 位置5removed
6. get keyB, 此时会出bug，会访问到位置6. 实际上应为keyB 已经删除了

* Update hash_map_open_addressing.java

* Update hash_map_open_addressing.java

---------

Co-authored-by: Yudong Jin <krahets@163.com>

codes/java/chapter_hashing/hash_map_open_addressing.java

@@ -9,46 +9,64 @@ package chapter_hashing;
 /* 开放寻址哈希表 */
 class HashMapOpenAddressing {
     private int size; // 键值对数量
-    private int capacity; // 哈希表容量
+    private int capacity = 4; // 哈希表容量
-    private double loadThres; // 触发扩容的负载因子阈值
+    private final double loadThres = 2.0 / 3; // 触发扩容的负载因子阈值
-    private int extendRatio; // 扩容倍数
+    private final int extendRatio = 2; // 扩容倍数
     private Pair[] buckets; // 桶数组
-    private Pair removed; // 删除标记
+    private final Pair TOMBSTONE = new Pair(-1, "-1"); // 删除标记
 
     /* 构造方法 */
     public HashMapOpenAddressing() {
         size = 0;
-        capacity = 4;
-        loadThres = 2.0 / 3.0;
-        extendRatio = 2;
         buckets = new Pair[capacity];
-        removed = new Pair(-1, "-1");
     }
 
     /* 哈希函数 */
-    public int hashFunc(int key) {
+    private int hashFunc(int key) {
         return key % capacity;
     }
 
     /* 负载因子 */
-    public double loadFactor() {
+    private double loadFactor() {
         return (double) size / capacity;
     }
 
+    /* 搜索 key 对应的桶索引 */
+    private int findBucket(int key) {
+        int index = hashFunc(key);
+        int firstTombstone = -1;
+        // 线性探测，当遇到空桶时跳出
+        while (buckets[index] != null) {
+            // 若遇到 key ，返回对应桶索引
+            if (buckets[index].key == key) {
+                // 若之前遇到了删除标记，则将键值对移动至该索引
+                if (firstTombstone != -1) {
+                    buckets[firstTombstone] = buckets[index];
+                    buckets[index] = TOMBSTONE;
+                    return firstTombstone; // 返回移动后的桶索引
+                }
+                return index; // 返回桶索引
+            }
+            // 记录遇到的首个删除标记
+            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {
+                firstTombstone = index;
+            }
+            // 计算桶索引，越过尾部返回头部
+            index = (index + 1) % capacity;
+        }
+        // 若 key 不存在，则返回添加点的索引
+        return firstTombstone == -1 ? index : firstTombstone;
+    }
+
     /* 查询操作 */
     public String get(int key) {
-        int index = hashFunc(key);
+        // 搜索 key 对应的桶索引
-        // 线性探测，从 index 开始向后遍历
+        int index = findBucket(key);
-        for (int i = 0; i < capacity; i++) {
+        // 若找到键值对，则返回对应 val
-            // 计算桶索引，越过尾部返回头部
+        if (buckets[index] != null && buckets[index] != TOMBSTONE) {
-            int j = (index + i) % capacity;
+            return buckets[index].val;
-            // 若遇到空桶，说明无此 key ，则返回 null
-            if (buckets[j] == null)
-                return null;
-            // 若遇到指定 key ，则返回对应 val
-            if (buckets[j].key == key && buckets[j] != removed)
-                return buckets[j].val;
         }
+        // 若键值对不存在，则返回 null
         return null;
     }
 
@@ -58,47 +76,31 @@ class HashMapOpenAddressing {
         if (loadFactor() > loadThres) {
             extend();
         }
-        int index = hashFunc(key);
+        // 搜索 key 对应的桶索引
-        // 线性探测，从 index 开始向后遍历
+        int index = findBucket(key);
-        for (int i = 0; i < capacity; i++) {
+        // 若找到键值对，则覆盖 val 并返回
-            // 计算桶索引，越过尾部返回头部
+        if (buckets[index] != null && buckets[index] != TOMBSTONE) {
-            int j = (index + i) % capacity;
+            buckets[index].val = val;
-            // 若遇到空桶、或带有删除标记的桶，则将键值对放入该桶
+            return;
-            if (buckets[j] == null || buckets[j] == removed) {
-                buckets[j] = new Pair(key, val);
-                size += 1;
-                return;
-            }
-            // 若遇到指定 key ，则更新对应 val
-            if (buckets[j].key == key) {
-                buckets[j].val = val;
-                return;
-            }
         }
+        // 若键值对不存在，则添加该键值对
+        buckets[index] = new Pair(key, val);
+        size++;
     }
 
     /* 删除操作 */
     public void remove(int key) {
-        int index = hashFunc(key);
+        // 搜索 key 对应的桶索引
-        // 线性探测，从 index 开始向后遍历
+        int index = findBucket(key);
-        for (int i = 0; i < capacity; i++) {
+        // 若找到键值对，则用删除标记覆盖它
-            // 计算桶索引，越过尾部返回头部
+        if (buckets[index] != null && buckets[index] != TOMBSTONE) {
-            int j = (index + i) % capacity;
+            buckets[index] = TOMBSTONE;
-            // 若遇到空桶，说明无此 key ，则直接返回
+            size--;
-            if (buckets[j] == null) {
-                return;
-            }
-            // 若遇到指定 key ，则标记删除并返回
-            if (buckets[j].key == key) {
-                buckets[j] = removed;
-                size -= 1;
-                return;
-            }
         }
     }
 
     /* 扩容哈希表 */
-    public void extend() {
+    private void extend() {
         // 暂存原哈希表
         Pair[] bucketsTmp = buckets;
         // 初始化扩容后的新哈希表
@@ -107,7 +109,7 @@ class HashMapOpenAddressing {
         size = 0;
         // 将键值对从原哈希表搬运至新哈希表
         for (Pair pair : bucketsTmp) {
-            if (pair != null && pair != removed) {
+            if (pair != null && pair != TOMBSTONE) {
                 put(pair.key, pair.val);
             }
         }
@@ -116,10 +118,12 @@ class HashMapOpenAddressing {
     /* 打印哈希表 */
     public void print() {
         for (Pair pair : buckets) {
-            if (pair != null) {
+            if (pair == null) {
-                System.out.println(pair.key + " -> " + pair.val);
-            } else {
                 System.out.println("null");
+            } else if (pair == TOMBSTONE) {
+                System.out.println("TOMBSTONE");
+            } else {
+                System.out.println(pair.key + " -> " + pair.val);
             }
         }
     }
@@ -127,28 +131,28 @@ class HashMapOpenAddressing {
 
 public class hash_map_open_addressing {
     public static void main(String[] args) {
-        /* 初始化哈希表 */
+        // 初始化哈希表
-        HashMapOpenAddressing map = new HashMapOpenAddressing();
+        HashMapOpenAddressing hashmap = new HashMapOpenAddressing();
 
-        /* 添加操作 */
+        // 添加操作
-        // 在哈希表中添加键值对 (key, value)
+        // 在哈希表中添加键值对 (key, val)
-        map.put(12836, "小哈");
+        hashmap.put(12836, "小哈");
-        map.put(15937, "小啰");
+        hashmap.put(15937, "小啰");
-        map.put(16750, "小算");
+        hashmap.put(16750, "小算");
-        map.put(13276, "小法");
+        hashmap.put(13276, "小法");
-        map.put(10583, "小鸭");
+        hashmap.put(10583, "小鸭");
         System.out.println("\n添加完成后，哈希表为\nKey -> Value");
-        map.print();
+        hashmap.print();
 
-        /* 查询操作 */
+        // 查询操作
-        // 向哈希表输入键 key ，得到值 value
+        // 向哈希表输入键 key ，得到值 val
-        String name = map.get(13276);
+        String name = hashmap.get(13276);
         System.out.println("\n输入学号 13276 ，查询到姓名 " + name);
 
-        /* 删除操作 */
+        // 删除操作
-        // 在哈希表中删除键值对 (key, value)
+        // 在哈希表中删除键值对 (key, val)
-        map.remove(16750);
+        hashmap.remove(16750);
         System.out.println("\n删除 16750 后，哈希表为\nKey -> Value");
-        map.print();
+        hashmap.print();
     }
 }