algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-11-02 21:24:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add the codes of hashmap (#553)

Browse Source 
of chaining and open addressing
This commit is contained in:
Yudong Jin
2023-06-14 02:01:06 +08:00
committed by GitHub
parent d3e597af94
commit 9563965a20
27 changed files with 1280 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
codes/cpp/chapter_hashing/array_hash_map.cpp
View File

@ -6,12 +6,12 @@
#include "../utils/common.hpp"
/* 键值对 int->String */
struct Entry {
/* 键值对 */
struct Pair {
public:
int key;
string val;
Entry(int key, string val) {
Pair(int key, string val) {
this->key = key;
this->val = val;
}
@ -20,12 +20,12 @@ struct Entry {
/* 基于数组简易实现的哈希表 */
class ArrayHashMap {
private:
vector<Entry *> buckets;
vector<Pair *> buckets;
public:
ArrayHashMap() {
// 初始化数组，包含 100 个桶
buckets = vector<Entry *>(100);
buckets = vector<Pair *>(100);
}
~ArrayHashMap() {
@ -45,7 +45,7 @@ class ArrayHashMap {
/* 查询操作 */
string get(int key) {
int index = hashFunc(key);
Entry *pair = buckets[index];
Pair *pair = buckets[index];
if (pair == nullptr)
return nullptr;
return pair->val;
@ -53,7 +53,7 @@ class ArrayHashMap {
/* 添加操作 */
void put(int key, string val) {
Entry *pair = new Entry(key, val);
Pair *pair = new Pair(key, val);
int index = hashFunc(key);
buckets[index] = pair;
}
@ -67,20 +67,20 @@ class ArrayHashMap {
}
/* 获取所有键值对 */
vector<Entry *> entrySet() {
vector<Entry *> entrySet;
for (Entry *pair : buckets) {
vector<Pair *> pairSet() {
vector<Pair *> pairSet;
for (Pair *pair : buckets) {
if (pair != nullptr) {
entrySet.push_back(pair);
pairSet.push_back(pair);
}
}
return entrySet;
return pairSet;
}
/* 获取所有键 */
vector<int> keySet() {
vector<int> keySet;
for (Entry *pair : buckets) {
for (Pair *pair : buckets) {
if (pair != nullptr) {
keySet.push_back(pair->key);
}
@ -91,7 +91,7 @@ class ArrayHashMap {
/* 获取所有值 */
vector<string> valueSet() {
vector<string> valueSet;
for (Entry *pair : buckets) {
for (Pair *pair : buckets) {
if (pair != nullptr) {
valueSet.push_back(pair->val);
}
@ -101,7 +101,7 @@ class ArrayHashMap {
/* 打印哈希表 */
void print() {
for (Entry *kv : entrySet()) {
for (Pair *kv : pairSet()) {
cout << kv->key << " -> " << kv->val << endl;
}
}
@ -135,7 +135,7 @@ int main() {
/* 遍历哈希表 */
cout << "\n遍历键值对 Key->Value" << endl;
for (auto kv : map.entrySet()) {
for (auto kv : map.pairSet()) {
cout << kv->key << " -> " << kv->val << endl;
}

149
codes/cpp/chapter_hashing/hash_map_chaining.cpp Normal file
View File

@ -0,0 +1,149 @@
/**
* File: hash_map_chaining.cpp
* Created Time: 2023-06-13
* Author: Krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 键值对 */
struct Pair {
public:
int key;
string val;
Pair(int key, string val) {
this->key = key;
this->val = val;
}
};
/* 链式地址哈希表 */
class HashMapChaining {
private:
int size; // 键值对数量
int capacity; // 哈希表容量
double loadThres; // 触发扩容的负载因子阈值
int extendRatio; // 扩容倍数
vector<vector<Pair *>> buckets; // 桶数组
public:
/* 构造方法 */
HashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3), extendRatio(2) {
buckets.resize(capacity);
}
/* 哈希函数 */
int hashFunc(int key) {
return key % capacity;
}
/* 负载因子 */
double loadFactor() {
return (double)size / (double)capacity;
}
/* 查询操作 */
string get(int key) {
int index = hashFunc(key);
// 遍历桶，若找到 key 则返回对应 val
for (Pair *pair : buckets[index]) {
if (pair->key == key) {
return pair->val;
}
}
// 若未找到 key 则返回 nullptr
return nullptr;
}
/* 添加操作 */
void put(int key, string val) {
// 当负载因子超过阈值时，执行扩容
if (loadFactor() > loadThres) {
extend();
}
int index = hashFunc(key);
// 遍历桶，若遇到指定 key ，则更新对应 val 并返回
for (Pair *pair : buckets[index]) {
if (pair->key == key) {
pair->val = val;
return;
}
}
// 若无该 key ，则将键值对添加至尾部
buckets[index].push_back(new Pair(key, val));
size++;
}
/* 删除操作 */
void remove(int key) {
int index = hashFunc(key);
auto &bucket = buckets[index];
// 遍历桶，从中删除键值对
for (int i = 0; i < bucket.size(); i++) {
if (bucket[i]->key == key) {
Pair *tmp = bucket[i];
bucket.erase(bucket.begin() + i); // 从中删除键值对
delete tmp; // 释放内存
size--;
return;
}
}
}
/* 扩容哈希表 */
void extend() {
// 暂存原哈希表
vector<vector<Pair *>> bucketsTmp = buckets;
// 初始化扩容后的新哈希表
capacity *= extendRatio;
buckets.clear();
buckets.resize(capacity);
size = 0;
// 将键值对从原哈希表搬运至新哈希表
for (auto &bucket : bucketsTmp) {
for (Pair *pair : bucket) {
put(pair->key, pair->val);
}
}
}
/* 打印哈希表 */
void print() {
for (auto &bucket : buckets) {
cout << "[";
for (Pair *pair : bucket) {
cout << pair->key << " -> " << pair->val << ", ";
}
cout << "]\n";
}
}
};
/* Driver Code */
int main() {
/* 初始化哈希表 */
HashMapChaining map = HashMapChaining();
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map.put(12836, "小哈");
map.put(15937, "小啰");
map.put(16750, "小算");
map.put(13276, "小法");
map.put(10583, "小鸭");
cout << "\n添加完成后，哈希表为\nKey -> Value" << endl;
map.print();
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
string name = map.get(13276);
cout << "\n输入学号 13276 ，查询到姓名 " << name << endl;
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.remove(12836);
cout << "\n删除 12836 后，哈希表为\nKey -> Value" << endl;
map.print();
return 0;
}

166
codes/cpp/chapter_hashing/hash_map_open_addressing.cpp Normal file
View File

@ -0,0 +1,166 @@
/**
* File: hash_map_open_addressing.cpp
* Created Time: 2023-06-13
* Author: Krahets (krahets@163.com)
*/
#include "../utils/common.hpp"
/* 键值对 */
struct Pair {
int key;
string val;
Pair(int k, string v) : key(k), val(v) {
}
};
/* 开放寻址哈希表 */
class HashMapOpenAddressing {
private:
int size; // 键值对数量
int capacity; // 哈希表容量
double loadThres; // 触发扩容的负载因子阈值
int extendRatio; // 扩容倍数
vector<Pair *> buckets; // 桶数组
Pair *removed; // 删除标记
public:
/* 构造方法 */
HashMapOpenAddressing() {
// 构造方法
size = 0;
capacity = 4;
loadThres = 2.0 / 3.0;
extendRatio = 2;
buckets = vector<Pair *>(capacity, nullptr);
removed = new Pair(-1, "-1");
}
/* 哈希函数 */
int hashFunc(int key) {
return key % capacity;
}
/* 负载因子 */
double loadFactor() {
return static_cast<double>(size) / capacity;
}
/* 查询操作 */
string get(int key) {
int index = hashFunc(key);
// 线性探测，从 index 开始向后遍历
for (int i = 0; i < capacity; i++) {
// 计算桶索引，越过尾部返回头部
int j = (index + i) % capacity;
// 若遇到空桶，说明无此 key ，则返回 nullptr
if (buckets[j] == nullptr)
return nullptr;
// 若遇到指定 key ，则返回对应 val
if (buckets[j]->key == key && buckets[j] != removed)
return buckets[j]->val;
}
return nullptr;
}
/* 添加操作 */
void put(int key, string val) {
// 当负载因子超过阈值时，执行扩容
if (loadFactor() > loadThres)
extend();
int index = hashFunc(key);
// 线性探测，从 index 开始向后遍历
for (int i = 0; i < capacity; i++) {
// 计算桶索引，越过尾部返回头部
int j = (index + i) % capacity;
// 若遇到空桶、或带有删除标记的桶，则将键值对放入该桶
if (buckets[j] == nullptr || buckets[j] == removed) {
buckets[j] = new Pair(key, val);
size += 1;
return;
}
// 若遇到指定 key ，则更新对应 val
if (buckets[j]->key == key) {
buckets[j]->val = val;
return;
}
}
}
/* 删除操作 */
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] == nullptr)
return;
// 若遇到指定 key ，则标记删除并返回
if (buckets[j]->key == key) {
delete buckets[j]; // 释放内存
buckets[j] = removed;
size -= 1;
return;
}
}
}
/* 扩容哈希表 */
void extend() {
// 暂存原哈希表
vector<Pair *> bucketsTmp = buckets;
// 初始化扩容后的新哈希表
capacity *= extendRatio;
buckets = vector<Pair *>(capacity, nullptr);
size = 0;
// 将键值对从原哈希表搬运至新哈希表
for (Pair *pair : bucketsTmp) {
if (pair != nullptr && pair != removed) {
put(pair->key, pair->val);
}
}
}
/* 打印哈希表 */
void print() {
for (auto &pair : buckets) {
if (pair != nullptr) {
cout << pair->key << " -> " << pair->val << endl;
} else {
cout << "nullptr" << endl;
}
}
}
};
/* Driver Code */
int main() {
/* 初始化哈希表 */
HashMapOpenAddressing map = HashMapOpenAddressing();
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map.put(12836, "小哈");
map.put(15937, "小啰");
map.put(16750, "小算");
map.put(13276, "小法");
map.put(10583, "小鸭");
cout << "\n添加完成后，哈希表为\nKey -> Value" << endl;
map.print();
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
string name = map.get(13276);
cout << "\n输入学号 13276 ，查询到姓名 " << name << endl;
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.remove(16750);
cout << "\n删除 16750 后，哈希表为\nKey -> Value" << endl;
map.print();
return 0;
}