哈希冲突(基于链式地址，实现哈希表)

哈希冲突

通常情况下，哈希函数的输入空间远远大于输出空间，因此，哈希冲突是不可避免的。

哈希冲突会导致查询结果错误，严重影响哈希表的可用性，为了解决该问题，我们一般是对哈希表进行扩容，直至冲突消失，但是这种方法效率太低。

对此，我们可以采用以下策略：

• 改良哈希表的数据结构，使得哈希表在出现哈希冲突时可以正常使用
• 当哈希冲突严重时，才进行扩容

哈希表的改良操作主要有“链式地址”和“开放寻址”

链式地址

在原始哈希表中每个桶只能存储一个键值对，链式地址将单个元素转换为链表，将键值对作为链表的节点，将有冲突的键值对存储在同一条链表中。

链式地址：每个桶存储一条链表，其中包括所有冲突的元素

基于链式地址实现的哈希表操作发生了变化

• 查询元素：输入key经过哈希函数得到索引，即可访问头节点，然后遍历链表，对比key以查找键值对
• 添加元素：通过哈希函数得到链表头节点，然后将键值对插入到链表
• 删除元素：通过哈希函数得到链表头节点，遍历链表查到目标节点将其删除。

局限性

• 占用空间变大：链表包含头指针，他比数组更耗费内存空间
• 查询效率低：因为要遍历链表

简单实现

• 当负载因子超过2/3，我们将哈希表扩容到原来的两倍

//
// Created by Administrator on 2024/1/12.
//
#include "iostream"
#include "vector"

using namespace std;

struct Pair{
    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> buckets; // 桶数组

public:
    /* 构造方法 */
    HashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3.0), extendRatio(2) {
        buckets.resize(capacity);
    }

    /* 析构方法 */
    ~HashMapChaining() {
        for (auto &bucket : buckets) {
            for (Pair *pair : bucket) {
                // 释放内存
                delete pair;
            }
        }
    }

    /* 哈希函数 */
    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 ，则返回空字符串
        return "";
    }

    /* 添加操作 */
    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> bucketsTmp = buckets;
        // 初始化扩容后的新哈希表
        capacity *= extendRatio;
        buckets.clear();
        buckets.resize(capacity);
        size = 0;
        // 将键值对从原哈希表搬运至新哈希表
        for (auto &bucket : bucketsTmp) {
            for (Pair *pair : bucket) {
                put(pair->key, pair->val);
                // 释放内存
                delete pair;
            }
        }
    }

    /* 打印哈希表 */
    void print() {
        for (auto &bucket : buckets) {
            cout << "[";
            for (Pair *pair : bucket) {
                cout << pair->key << " -> " << pair->val << ", ";
            }
            cout << "]\n";
        }
    }
};

int main(){
    cout<<"链式地址哈希表"<

开放寻址

不引入额外的数据结构，是通过”多次探测“来处理哈希冲突，包括：线性探测，平方探测，多次哈希

线性探测

使用固定步长来进行探测

• 插入元素：通过哈希函数计算索引，若该索引已经有了元素，则从冲突位置后开始线性遍历，直至找到空索引，将其插入。
• 查找元素：通过哈希函数计算索引，如果发生了哈希冲突，则使用相同的步长进行线性遍历，找到目标元素返回即可，如果遇见空索引，则说明没有该元素。

缺点

• 线性探测容易产生”聚集现象“：数组中连续被占用位置越长，这些连续位置发生哈希冲突的可能性越大
• 不能在开放寻址哈希表中直接删除元素：当你删除一个元素后，此时这个索引为空，当查询元素时，线性探测遇见空就会返回，该索引之后的位置都不能被访问。

解决方法

• 采用懒删除机制：不是从哈希表中删除，而是使用一个标志变量来标记，线性探测遇到这个标记后会继续遍历

平方探测

当发生冲突时，平方探测不是简单地跳过一个固定的步数，而是跳过“探测次数的平方”的步数，即 1,4,9,… 步

优势

• 平方探测通过跳过探测次数平方的距离，试图缓解线性探测的聚集效应
• 平方探测会跳过更大的距离来寻找空位置，有助于数据分布得更加均匀

缺点

• 仍然存在聚集现象，即某些位置比其他位置更容易被占用。
• 由于平方的增长，平方探测可能不会探测整个哈希表，这意味着即使哈希表中有空桶，平方探测也可能无法访问到它

多次哈希

顾名思义，多次哈希方法使用多个哈希函数进行探测。

• 插入元素：若哈希函数f1(x) 出现冲突，则尝试 f2(x)，以此类推，直到找到空位后插入元素。
• 查找元素：在相同的哈希函数顺序下进行查找，直到找到目标元素时返回；若遇到空位或已尝试所有哈希函数，说明哈希表中不存在该元素，则返回空

关注微信公众号：IT零壹学府,每日分享自己的学习经验