【数据结构】了解哈希表,解决哈希冲突,用Java模拟实现哈希桶

哈希表的概念

哈希表(Hash Table)是一种高效的数据结构,用于实现快速的数据存储和检索。它通过将数据映射到一个数组的索引位置,从而能够在平均情况下实现O(1)的时间复杂度进行查找、插入和删除操作。

哈希表的基本概念包括以下几个部分:

  1. 哈希函数:哈希表使用哈希函数将输入的数据(通常是键)转换为固定大小的数组索引。一个好的哈希函数能够有效地将不同的数据映射到不同的索引,减少冲突的概率。

  2. 冲突处理:由于不同的键可能会通过哈希函数映射到相同的索引,这种情况被称为冲突。常见的冲突处理方法有链地址法(在同一个索引处使用链表存储所有冲突的元素)和开放地址法(通过探测寻找下一个可用的索引)。

  3. 负载因子:负载因子是哈希表中存储的元素数量与哈希表大小的比率。负载因子过高会导致冲突增加,影响性能,因此通常在达到一定的负载因子后会对哈希表进行扩展和重新哈希。

哈希表在实际应用中广泛用于快速查找和存储数据,例如数据库索引、缓存系统等,是一种非常实用的数据结构。

例如:数据集合{1,7,6,4,5,9}。

哈希函数设置为:hash(key) = key % capacity; capacity为存储元素底层空间总的大小。

哈希冲突的概念

哈希冲突(Hash Collision)是指在哈希表中,不同的输入数据(通常是键)经过哈希函数处理后,得到了相同的哈希值,进而映射到了哈希表的同一个索引位置。这种现象不可避免,因为哈希函数将任意大小的数据映射到固定大小的数组索引,而输入数据的范围通常大于输出哈希值的范围,从而导致不同的数据可能会对应相同的哈希值。

哈希冲突的处理方法:

为了有效地处理哈希冲突,主要有以下几种常见的方法:

  1. 链地址法(Separate Chaining)

    • 在哈希表的每个索引位置,使用一个链表或其他数据结构来存储所有哈希值相同的元素。这样,当发生冲突时,新元素可以直接添加到链表中。
    • 优点:实现简单,容易扩展,链表的长度通常是较短的,性能受到较少影响。
    • 缺点:当冲突严重时,链表长度增加,会影响查找性能。
  2. 开放地址法(Open Addressing)

    • 当发生哈希冲突时,哈希表会寻找下一个空闲的位置,将新元素放入该位置,而不是在同一索引位置存储。
    • 包括线性探测、二次探测和双重哈希等具体策略来寻找空位。
    • 优点:内存占用较低,数据存储在连续的数组中,缓存友好。
    • 缺点:可能导致"聚集"现象,即连续的多个元素都占据相邻的索引,影响性能。

哈希冲突的影响:

哈希冲突的存在会对哈希表的性能产生影响,特别是在查找、插入和删除元素时。冲突越多,导致的查找时间可能从O(1)增长到O(n)(在最坏的情况下)。因此,选择合适的哈希函数以减少冲突的发生,以及选择有效的冲突处理策略,是设计高效哈希表的关键。

避免哈希冲突的方法

哈希函数设计

引起哈希冲突的一个原因可能是:哈希函数设计不够合理。 哈希函数设计原则:

  • 哈希函数的定义域必须包括需要存储的全部关键码,而如果散列表允许有m个地址时,其值域必须在0到m-1之间。
  • 哈希函数计算出来的地址能均匀分布在整个空间中。
  • 哈希函数应该比较简单。

常见哈希函数

直接定制法

取关键字的某个线性函数为散列地址:Hash(Key)= A*Key + B 优点:简单、均匀 缺点:需要事先知道关键字的分布情况 使用场景:适合查找比较小且连续的情况。

除留余数法

设散列表中允许的地址数为m,取一个不大于m,但最接近或者等于m的质数p作为除数,按照哈希函数:Hash(key) = key% p(p<=m),将关键码转换成哈希地址。

平方取中法

假设关键字为1234,对它平方就是1522756,抽取中间的3位227作为哈希地址; 再比如关键字为4321,对它平方就是18671041,抽取中间的3位671(或710)作为哈希地址 平方取中法比较适合:不知道关键字的分布,而位数又不是很大的情况。

折叠法

折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些),然后将这几部分叠加求和,并按散列表表长,取后几位作为散列地址。

随机数法

选择一个随机函数,取关键字的随机函数值为它的哈希地址,即H(key) = random(key),其中random为随机数函数。

负载因子调节

负载因子(Load Factor)是哈希表中一个重要的度量,用于评估哈希表的使用效率和性能。负载因子定义为哈希表中存储的元素数量与哈希表的总容量(即数组大小)之间的比率,通常用公式表示为:

负载因子 = 当前元素数量 / 哈希表的容量

负载因子的意义:

  1. 性能指标:负载因子能够反映哈希表的性能。当负载因子较低时,哈希表中的元素分布较为稀疏,冲突较少,查找、插入和删除操作的效率较高。而当负载因子较高时,冲突可能增多,导致这些操作的性能下降。

  2. 自适应调整:为了保持哈希表的高效性能,通常在负载因子达到一定阈值时(例如0.7或0.75),会进行负载因子的调节。调节方法通常包括扩展哈希表的容量,并重新计算所有元素的哈希值以保证它们被均匀分布。

负载因子的调节过程:

  1. 扩展哈希表:当负载因子超过预设阈值时,哈希表需要扩展容量,通常会将哈希表的容量增加为原来的两倍,或者其他合适的数值。

  2. 重新哈希:扩展容量后,所有现有元素必须经过哈希函数重新计算哈希值,并根据新容量重新分配到新的索引位置。这一过程被称为重新哈希(Rehashing)。

  3. 减少容量:在某些情况下,如果哈希表中的元素数量显著减少,负载因子低于某一阈值,可能会考虑缩减哈希表的容量,以减少空间浪费。

总结:

通过合理地调节负载因子,可以保持哈希表高效的性能,降低冲突率,并确保在各种操作下的时间复杂度保持尽可能接近O(1)。在设计哈希表时,选择合适的负载因子阈值和扩展策略是至关重要的。

解决哈希冲突的方法

开放地址法(闭散列)

闭散列:也叫开放定址法,当发生哈希冲突时,如果哈希表未被装满,说明在哈希表中必然还有空位置,那么可以把key存放到冲突位置中的"下一个" 空位置中去。

线性探测

线性探测(Linear Probing)是一种开放地址法的冲突解决策略,主要用于处理哈希表中的哈希冲突。当多个元素通过哈希函数映射到相同的索引位置时,线性探测使用线性搜索的方法寻找下一个可用的位置来存放新元素。

线性探测的工作原理:
  1. 哈希插入

    • 当需要插入一个元素到哈希表时,首先计算该元素的哈希值,找到其对应的数组索引。
    • 如果该索引位置已经被占用(发生冲突),则按顺序检查后续的索引(即当前索引 + 1,当前索引 + 2,依此类推)。
    • 继续检查直到找到一个空闲的索引位置,将新元素插入。
  2. 哈希查找

    • 查找一个元素时,同样计算出其哈希值并找到对应的索引。
    • 如果该位置的元素与查找的元素不匹配,就沿着线性探测的方式依次检查下一个索引。
    • 如果遇到空位,说明该元素不在表中;如果找到匹配的元素,则返回该元素。
  3. 哈希删除

    • 删除元素时,可以简单地将对应的索引位置设置为"删除"状态(或特殊标记),但仍需注意后续查找时的线性探测,以防止链式冲突查找的失败。
线性探测的优缺点:

优点

  • 实现简单,逻辑清晰。
  • 在有序的序列中存储元素时,能够保持元素的连贯性,提高缓存命中率。

缺点

  • 聚集现象(Clustering):线性探测容易导致"聚集"现象,即相邻的元素趋向于占用相邻的索引,这会影响后续插入和查找的效率。
  • 在负载因子较高时,性能会显著下降,查找时间可能接近O(n)。

总结:

线性探测是一种简洁而有效的冲突解决策略,适用于负载因子较低的哈希表。在负载因子过高时,考虑其他冲突解决方法(如链地址法或二次探测)可能会得到更好的性能表现。

二次探测

二次探测(Quadratic Probing)是一种开放地址法的冲突解决策略,用于哈希表中处理哈希冲突。与线性探测不同,二次探测通过使用平方函数生成一个探测序列,以寻找下一个可用的位置。

二次探测的工作原理:
  1. 哈希查找

    • 查找一个元素时,同样计算出其哈希值并找到对应的索引。
    • 如果该位置的元素不匹配所查找的元素,则按二次探测的方式依次检查后续索引(即使用平方探测公式)。
    • 如果遇到空位,说明该元素不在表中;如果找到匹配的元素,则返回该元素。
  2. 哈希删除

    • 删除元素时,可以将对应的索引位置设置为"删除"状态(或特殊标记),这需要特别注意,因为后续查找仍会使用该位置进行探测。
二次探测的优缺点:

优点

  • 相比线性探测,二次探测能减少聚集现象(Clustering)。由于索引在探测中不再是线性分布,避免了多个元素趋向于占用相邻空间的问题。
  • 在一定程度上,能够提高查找和插入操作的效率,特别是当负载因子较高时。

缺点

  • 由于使用平方函数,可能形成某些未探测到的索引,从而造成一些空间浪费。
  • 实现相对较复杂,特别是在处理数组大小不是2的幂时,可能需要额外的处理逻辑以确保探测的覆盖性。

总结:

二次探测是一种有效的冲突解决策略,适用于哈希表需要保持较低负载因子且冲突较多的情况。通过减少聚集现象,二次探测可以在一定程度上提高哈希表的效率,但在实现上需要关注数组大小和探测方式的合理性。

链地址法(开散列)

链地址法(Separate Chaining)是一种用于处理哈希表中哈希冲突的常见策略。在哈希表中,当多个元素通过哈希函数映射到相同的索引位置时,链地址法能够有效地将这些元素组织在一起,避免冲突造成的元素丢失。

链地址法的工作原理:

  1. 哈希表结构

    • 哈希表的每个索引位置通常是一个指向链表(或其他数据结构,如树)的指针。这意味着每个索引位置可以存储多个元素。
  2. 哈希插入

    • 当需要插入一个元素时,首先计算该元素的哈希值,找到对应的索引位置。
    • 如果该位置为空,直接将元素放入;如果该位置已经有元素,则将新元素添加到该索引位置对应的链表中(可以是链表的头部或尾部,具体实现可以不同)。
  3. 哈希查找

    • 查找某个元素时,同样计算元素的哈希值,并找到对应的索引位置。
    • 在该位置的链表中进行线性搜索,查找是否存在与目标元素相匹配的值。
  4. 哈希删除

    • 删除元素时,先找到元素的哈希值对应的链表,然后在链表中进行查找,如果找到匹配的元素,就将其从链表中移除。

链地址法的优缺点:

优点

  • 实现简单,逻辑清晰,能够有效地处理冲突而不影响其他元素的存储。
  • 不需要在插入时重新计算和移动其他元素,扩展性较好。
  • 适合负载因子较高的情况,只要存储的链表不会过长,性能依然可以得到保证。

缺点

  • 在负载因子很高的情况下,链表长度可能增加,查找性能可能退化到O(n)。
  • 每个索引位置可能占用额外的存储空间,特别是在链表较长时,内存使用不是很高效。
  • 需要处理内存管理(如动态分配和释放),可能增加实现的复杂性。

总结:

链地址法是一种有效的哈希冲突解决策略,能够通过将冲突元素存储在链表中来维持哈希表的高效性。其简单易实现的特性使其在许多实际应用中得到了广泛的采用,尤其是在预期有较多冲突的情况下,能够保持较好的性能。

代码模拟实现链地址法(哈希桶)

java 复制代码
public class HashBuck {
    static class Node {
        public int key;
        public int value;
        public Node next;

        public Node(int key,int val) {
            this.key = key;
            this.value = val;
        }
    }

    public Node[] elem;
    public int usedSize;

    public HashBuck() {
        this.elem = new Node[10];
    }

    //往哈希桶里面放元素
    public void put(int key,int val) {
        Node node = new Node(key,val);
        int tmp = key % this.elem.length;
        Node cur = this.elem[tmp];
        while(cur.next != null) {
            if(cur.value == val) {
                cur.value = val;
                return;
            }
            cur = cur.next;
        }
        cur.next = node;
        this.usedSize++;
        //负载因子超过了0.75,需要扩容
        if(loadFactor() >= 0.75) {
            //调用扩容函数
            resize();
        }
    }
    //扩容函数
    private void resize() {
        Node[] tmpArr = new Node[this.elem.length*2];
        for (int i = 0; i < this.elem.length; i++) {
            Node cur = this.elem[i];
            while(cur != null) {
                //记录cur.next的位置
                Node curNext = cur.next;
                int newIndex = cur.key / tmpArr.length;
                //头插法
                cur.next = tmpArr[newIndex];
                tmpArr[newIndex] = cur;
                cur = curNext;
            }
        }

        this.elem = tmpArr;
    }
    //求出当前负载因子
    private double loadFactor() {
        return this.usedSize*1.0 / this.elem.length;
    }

    //给定一个key值在哈希桶里面找到并返回其value值
    public int get(int key) {
        int index = key % this.elem.length;
        Node cur = this.elem[index];
        while(cur != null) {
            if(cur.key == key) {
                return cur.value;
            }
            cur = cur.next;
        }
        return -1;
    }
}
相关推荐
pianmian12 小时前
python数据结构基础(7)
数据结构·算法
ChoSeitaku5 小时前
链表交集相关算法题|AB链表公共元素生成链表C|AB链表交集存放于A|连续子序列|相交链表求交点位置(C)
数据结构·考研·链表
偷心编程5 小时前
双向链表专题
数据结构
香菜大丸5 小时前
链表的归并排序
数据结构·算法·链表
jrrz08285 小时前
LeetCode 热题100(七)【链表】(1)
数据结构·c++·算法·leetcode·链表
@小博的博客5 小时前
C++初阶学习第十弹——深入讲解vector的迭代器失效
数据结构·c++·学习
泉崎7 小时前
11.7比赛总结
数据结构·算法
有梦想的咸鱼_7 小时前
go实现并发安全hashtable 拉链法
开发语言·golang·哈希算法
你好helloworld7 小时前
滑动窗口最大值
数据结构·算法·leetcode
JSU_曾是此间年少8 小时前
数据结构——线性表与链表
数据结构·c++·算法