C++实现哈希散列表的示例

// 创建日期：2022-07-13
// 作者：YZM
// 参考：https://GitHub1s.com/ACking-you/my_tiny_stl/blob/HEAD/src/Data_struct_tool/HashTable/sample_HashMap.h
#pragma once
#ifndef SAMPLE_HASHMAP_H
#define SAMPLE_HASHMAP_H
 
#include<iOStream>
#include<vector>
using namespace std;
 
template<typename T>
struct node {
    Node* next;
    T val;
    Node() :next(nullptr), val(0) {};
    Node(T _val) :next(nullptr), val(_val) {};
    Node(T _val, Node* nxt) :next(nxt), val(_val) {};
};
 
template<typename T>
class HashTable {
private:
    const static int init_buckets_size = 49; // 桶的初始数量
    int buckets_size; // 桶的数量
    int keys_count; // key的数量
    vector<Node<T>>buckets; // 不定义成指针类型，免去初始化的步骤
    int hashfun(T val); // 哈希函数
public:
    HashTable();
    ~HashTable();
    int& operator[](int index) const; // 重载[]运算符，哈希表暂时用不到
    void insert(T val); // 插入
    void erase(T val); // 删除
    bool find(T val); // 寻找
    void expand(); // 扩容
    void clear(); // 清空并释放资源
    void print(); // 打印检查
};
#endif 

#include "sample_hashmap.h"
using namespace std;
 
template<typename T>
HashTable<T>::HashTable():buckets_size(init_buckets_size), keys_count(0), buckets(vector<Node<T>>(init_buckets_size)){}
 
template<typename T>
HashTable<T>::~HashTable() {
    clear();
}
 
template<typename T>
int HashTable<T>::hashfun(T val) {
    return val % buckets_size;
}
 
template<typename T>
void HashTable<T>::insert(T val) {
    int key = hashfun(val);
    Node<T>* newNode = new Node<T>(key);
    newNode->next = buckets[key].next;
    buckets[key].next = newNode;
    ++keys_count;
    expand();
}
 
template<typename T>
void HashTable<T>::erase(T val) {
    int key = hashfun(val);
    Node<T>* cur = buckets[key].next; // 数组元素是结构体对象，.next调出结构体成员.
    Node<T>* pre = nullptr;
    while (cur) {
        if (cur->val == val) {
            if (pre == nullptr) {
                buckets[key].next = cur->next;
                delete cur;
            }
            else {
                pre->next = cur->next;
                delete cur;
            }
            return;
        }
        pre = cur;
        cur = cur->next;
    }
    --keys_count;
}
 
template<typename T>
bool HashTable<T>::find(T val) {
    int key = hashfun(val);
    Node<T>* cur = buckets[key].next;
    while (cur) {
        if (cur->val == val) return true;
        cur = cur->next;
    }
    return false;
}
 
template<typename T>
void HashTable<T>::clear() {
    for (int i = 0; i < buckets_size; ++i) {
        Node<T>* cur = buckets[i].next;
        while (cur) {
            Node<T>* pre = cur;
            cur = cur->next;
            delete pre;
        }
        buckets[i].next = nullptr;
    }
}
 
template<typename T>
void HashTable<T>::expand() {
    if (keys_count > buckets_size) {
        buckets_size <<= 1;
        buckets.resize(buckets_size);
    }
}
 
template<typename T>
void HashTable<T>::print() {
    for (int i = 0; i < buckets_size; ++i) {
        Node<T>* cur = buckets[i].next;
        while (cur) {
            cout << cur->val << ' ';
            cur = cur->next;
        }
    }
    cout << endl;
}
 
int main() {
    HashTable<int>hash;
    hash.insert(4);
    hash.print();
    hash.clear();
    hash.print();
    hash.insert(4);
    hash.print();
    hash.erase(4);
    hash.print();
    return 0;
}