• 【数据结构】哈希表

    1.前言

    我们前面学习了二叉搜索树的相关操作、Map和Set的使用，今天继续跟大家分享数据结构中的哈希表相关知识，让我们一起进入数据结构的世界，探索哈希表的奥秘！

    2.哈希表

    2.1概念

    顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(log₂N)，搜索的效率取决于搜索过程中元素的比较次数。

    理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

    当向该结构中：

    • 插入元素

    根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放。

    • 搜索元素
    对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。
    该方式即为哈希 ( 散列 ) 方法， 哈希方法中使用的转换函数称为哈希 ( 散列 ) 函数，构造出来的结构称为哈希表 (Hash Table)( 或者称散列表 )
    例如：数据集合 {1 ， 7 ， 6 ， 4 ， 5 ， 9} ；
    哈希函数设置为： hash(key) = key % capacity ; capacity 为存储元素底层空间总的大小。

    用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快。

    2.2冲突-概念

    对于两个数据元素的关键字 ki 和 k(j)，有ki != kj，但有：Hash(ki) == Hash(kj)，即：不同关键字通过相同哈希函数计算出相同的哈希地址，该现象称为哈希冲突或哈希碰撞。

    因此我们把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

    2.3冲突-避免

    我们需要明确一点，由于我们哈希表底层数组的容量往往是小于实际要存储的关键字的数量的，这就导致一个问题， 冲突的发生是必然的 ，但我们能做的应该是尽量的 降低冲突率 。

    2.3.1哈希函数设计

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

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

    常见哈希函数

    1.直接定制法

    取关键字的某个线性函数为散列地址： Hash （ Key ） = A*Key + B
    优点： 简单、均匀
    缺点： 需要事先知道关键字的分布情况
    使用场景： 适合查找比较小且连续的情况 
    1. class Solution {
    2.     public int firstUniqChar(String s) {
    3.         int[] arr =new int[26];
    4.         for(int i = 0;i
    5.         char ch = s.charAt(i);
    6.         arr[ch-'a']++;
    7.         }
    8.         for(int i = 0;i
    9.         char ch = s.charAt(i);
    10.         if (arr[ch - 'a'] == 1) {
    11.             return i;
    12.         }
    13.         }
    14.         return-1;
    15.     }
    16. }
    2. 除留余数法
    设散列表中允许的 地址数为 m ，取一个不大于 m ，但最接近或者等于 m 的质数 p 作为除数，按照哈希函数： Hash(key) = key% p(p<=m), 将关键码转换成哈希地址。
    3. 平方取中法
    假设关键字为 1234 ，对它平方就是 1522756 ，抽取中间的 3 位 227 作为哈希地址；再比如关键字为 4321 ，对它平方就是18671041 ，抽取中间的 3 位 671( 或 710) 作为哈希地址 平方取中法比较适合：不知道关键字的分 布，而位数又不是很大的情况。

    2.3.2负载因子调节

    负载因子和冲突率的关系粗略演示

    所以当冲突率达到一个无法忍受的程度时，我们需要通过降低负载因子来变相的降低冲突率。
    已知哈希表中 已有的关键字个数是不可变 的，那我们能调整的就只有哈希表中的数组的大小。

    2.4冲突-解决

    2.4.1闭散列

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

    比如上面的场景，现在需要插入元素 44 ，先通过哈希函数计算哈希地址，下标为 4 ，因此 44 理论上应该插在该位置，但是该位置已经放了值为4 的元素，即发生哈希冲突。

    1.线性探测

    线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

    插入：

    • 通过哈希函数获取待插入元素在哈希表中的位置；
    • 如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素。

    采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。

    2. 二次探测

    线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后去找，因此二次探测为了避免该问题，找下一个空位置的方法为：Hi = (H0 + i²) % m，或者：Hi = (H0 - i²) % m。其中：i = 1，2，3…，H0是通过散列函数Hash(x)对元素的关键码key进行计算得到的位置，m是表的大小。

    研究表明：当表的长度为质数且表装载因子 a 不超过 0.5 时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a 不超过 0.5 ，如果超出必须考虑增容。
    因此：比散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

    2.4.2开散列/哈希桶

    开散列法又叫链地址法 ( 开链法 ) ，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

    从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。
    因此开散列，我们可以认为是把一个在大集合中的搜索问题转化为在小集合中进行搜索。
    我们上面提到哈希桶其实可以看作将大集合的搜索问题转化为小集合的搜索问题了，那如果冲突严重，就意味着小集合的搜索性能其实也时不佳的，这个时候我们就可以将这个所谓的小集合搜索问题继续进行转化，例如：
    1. 每个桶的背后是另一个哈希表
    2. 每个桶的背后是一棵搜索树
    哈希桶代码实现如下所示： 
    1. public class HashBuck {
    2.     //哈希桶
    3.     static class Node {
    4.         public int key;
    5.         public int val;
    6.         public Node next;
    7.  
    8.         public Node(int key, int val) {
    9.             this.key = key;
    10.             this.val = val;
    11.         }
    12.     }
    13.  
    14.     public Node[] arr;
    15.     public int usedSize;
    16.     public double loadFactorCount = 0.75;
    17.  
    18.     public HashBuck() {
    19.         arr = new Node[10];
    20.     }
    21.  
    22.     public void put(int key, int val) {
    23.         int index = key % arr.length;
    24.         Node cur = arr[index];
    25.         //1.遍历当前链表，是否存在当前值
    26.         while (cur != null) {
    27.             if (cur.key == key) {
    28.                 cur.val = val;
    29.                 return;
    30.             }
    31.             cur = cur.next;
    32.         }
    33.         //2.说明没有当前值，此时进行头插
    34.         Node node = new Node(key, val);
    35.         node.next = arr[index];
    36.         arr[index] = node;
    37.         usedSize++;
    38.         //3.超过负载因子0.75进行扩容
    39.         if (loadFactorCount() >= loadFactorCount) {
    40.             //对数组进行扩容
    41.             resize();
    42.         }
    43.  
    44.     }
    45.  
    46.     private void resize() {
    47.         Node[] arr1 = new Node[arr.length * 2];
    48.         for (int i = 0; i < arr.length; i++) {
    49.             Node cur = arr[i];
    50.             //开始遍历链表
    51.             while (cur != null) {
    52.                 int index1 = cur.key % arr1.length;
    53.                 //把数据存放在新数组arr1位置
    54.                 Node cur1 = cur.next;
    55.                 cur.next = arr1[index1];
    56.                 arr1[index1] = cur;
    57.                 cur = cur1;
    58.             }
    59.         }
    60.         arr = arr1;
    61.     }
    62.  
    63.     private double loadFactorCount() {
    64.         return usedSize * 1.0 / arr.length;
    65.     }
    66.  
    67.     public int get(int key) {
    68.         int index = key % arr.length;
    69.         Node cur = arr[index];
    70.         while (cur != null) {
    71.             if (cur.key == key) {
    72.                 return cur.val;
    73.             }
    74.             cur = cur.next;
    75.         }
    76.         return -1;
    77.     }
    78. }
    1. public class Test {
    2.     public static void main(String[] args) {
    3.         HashBuck hashBuck = new HashBuck();
    4.         hashBuck.put(1,20);
    5.         hashBuck.put(14,22);
    6.         hashBuck.put(8,11);
    7.         hashBuck.put(6,99);
    8.         hashBuck.put(9,41);
    9.         System.out.println(hashBuck.get(8));
    10.     }
    11. }

    2.5性能分析

    虽然哈希表一直在和冲突做斗争，但在实际使用过程中，我们认为哈希表的冲突率是不高的，冲突个数是可控的，也就是每个桶中的链表的长度是一个常数，所以，通常意义下，我们认为哈希表的插入 / 删除 / 查找时间复杂度是 O(1) 。

    3.哈希表和 java 类集的关系

    1. HashMap 和 HashSet 即 java 中利用哈希表实现的 Map 和 Set

    2. java 中使用的是哈希桶方式解决冲突的

    3. java 会在冲突链表长度大于一定阈值后，将链表转变为搜索树（红黑树）

    4. java 中计算哈希值实际上是调用的类的 hashCode 方法，进行 key 的相等性比较是调用 key 的 equals 方 法。所以如果要用自定义类作为 HashMap 的 key 或者 HashSet 的值， 必须覆写 hashCode 和 equals 方 法 ，而且要做到 equals 相等的对象， hashCode 一定是一致的。

    4..总结

    哈希表是一种高效的数据结构，它通过哈希函数将元素的关键码映射到存储位置，以实现快速搜索、插入和删除操作。为了避免哈希冲突，我们可以通过设计合理的哈希函数、调整负载因子和解决冲突来降低冲突率，常见的哈希函数有直接定制法、除留余数法和平方取中法，以上就是本次所介绍的内容，我们下次再见。

  • 相关阅读:
    Java基础面试题
    Spring Boot爬虫实战：模拟点击按钮下载表格详解
    String_JavaScript
    基因检测技术的发展与创新：安全文件数据传输的重要作用
    Journal of statistical software:追踪前沿的统计学软件
    极客时间 - 《Linux 性能优化实战》
    ps找不到msvcp140.dll怎么办？亲测5个有效的修复方法分享
    Linux驱动调试之printk的使用
    【JavaScript】一文了解JS原型与原型链
    高通量测序的数据处理与分析指北(二)-宏基因组篇
  • 原文地址：https://blog.csdn.net/m0_74336101/article/details/140914854