yetao
/
hello-algo
mirror of https://github.com/krahets/hello-algo.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix: Update hash_map_open_addressing.java (#727)

Browse Source 
* 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>
pull/776/head
lyl625760 1 year ago committed by GitHub
parent 8effa58a59
commit 45e20e57a1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 78 additions and 74 deletions
Show Stats Download Patch File Download Diff File

152
codes/java/chapter_hashing/hash_map_open_addressing.java
Unescape View File

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

Write Preview
Loading…
Cancel
Save