Java数据结构学习DAY8——搜索树和哈希表（三）_java查找树和哈希表-优快云博客

本文介绍了哈希表，它能使元素存储位置与关键码建立映射，提高搜索效率。同时阐述了哈希冲突的概念，介绍了常见哈希函数、负载因子。还讲解了闭散列和开散列两种解决冲突的方法，分析了哈希表性能，并说明了其与Java类集如HashMap、HashSet的关系。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

哈希表目录

6. 哈希表

6. 哈希表

6.1 什么是哈希表

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( $log_2 N$ )，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。
如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中：

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

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

6.2 什么是哈希冲突

对于两个数据元素的关键字 $k_i$ 和 $k_j$ (i != j)，有 $k_i$ != $k_j$ ，但有：Hash( $k_i$ ) ==Hash( $k_j$ )，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。
把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

6.3 哈希函数设计

首先，我们需要明确一点，由于我们哈希表底层数组的容量往往是小于实际要存储的关键字的数量的，这就导致一个问题，冲突的发生是必然的，但我们能做的应该是尽量的降低冲突率。
引起哈希冲突的一个原因可能是：哈希函数设计不够合理。

常见哈希函数

直接定制法–(常用)
取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B
优点：简单、均匀
缺点：需要事先知道关键字的分布情况
使用场景：适合查找比较小且连续的情况
面试题：字符串中第一个只出现一次字符
除留余数法–(常用)
设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址。

6.4 负载因子

负载因子就是：衡量当前这个 hash 表中元素的拥挤程度。
用 hash 表中的总的元素个数除以出租长度称为负载因子。

6.5 解决冲突-闭散列

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

线性探测
线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
比如下面的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，下标为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。

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

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

6.6 解决冲突-开散列/哈希桶

开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
在这里插入图片描述
从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。使用开散列的方式解决冲突，还是有可能会出现某个下标位置链表特别长的情况。此时我们的优化手段有：

尝试扩容；
把较长的链表转换成一个红黑树/哈希表

开散列，可以认为是把一个在大集合中的搜索问题转化为在小集合中做搜索了。

6.7 开散列/哈希桶的实现

package Java42_0328;

class HashNode {
    public int key;
    public int value;
    public HashNode next;

    public HashNode(int key, int value) {
        this.key = key;
        this.value = value;
    }
}
// 开散列/哈希桶的方式来处理哈希冲突
public class MyHashMap {

    private HashNode[] array = new HashNode[16];
    private int size = 0;//当前hash表中一共有多少个元素


    public void put(int key, int value) {
        //1.先把 key 转成数组下标
        //  这里简单粗暴的使用除留取余的方式来计算 hash
        //  实际开发中会有一些更加高效的哈希函数。
        int index = key % array.length;
        //2. 先遍历该位置的链表，看看 key 是不是已经存在了
        //   如果 key 已经存在，就不必插入新的节点，直接修改 value 即可。
        for (HashNode cur = array[index]; cur != null; cur = cur.next) {
            if (cur.key == key) {
                //找到了 key， 直接修改 value；
                cur.value = value;
                return;
            }
        }
        //3. 如果不存在相同的key 就创建一个新节点
        HashNode newNode = new HashNode(key, value);
        //   直接链表头插即可
        newNode.next = array[index];
        array[index] = newNode;
        size++;

        //4. 判定 size 是否达到一定的数值，如果达到数值就扩容
        //这里的负载因子达到多少才扩容呢？最好根据实际情况，做实验试试。
        //负载因子越小，此时空间利用率越低
        //负载因子越大，此时性能可能就会收到影响。
        //此处的 0.75 ,java 标准库的 HashMap 负载因子阈值的默认值就是 0.75
        if (loadFactor() > 0.75) {
            resize();
        }
    }

    private void resize() {
        //创建一个正常的数组，把我们原来的数组拷贝进去
        HashNode[] newArray = new HashNode[array.length * 2];
        for (int i = 0; i < array.length; i++) {
            //遍历当前链表
            HashNode next = null;
            for (HashNode cur = array[i]; cur != null; cur = next) {
                cur = cur.next;//修改 cur.next 之前，先备份之前的位置
                //把当前 cur 指向的节点插入到新的数组上
                int indexNew = cur.key % newArray.length;
                //头插操作
                cur.next = newArray[indexNew];
                newArray[indexNew] = cur;

            }
        }
    }

    private double loadFactor(){
        return (double)size / array.length;
    }

    public Integer get(int key) {
        //先根据 key 计算得到一个 index
        //在遍历链表记即可
        int index = key % array.length;
        for (HashNode cur = array[index]; cur != null; cur = cur.next){
            if (cur.key == key) {
                return cur.value;
            }
        }
        return null;
    }
}

6.8 性能分析

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

6.9 和 java 类集的关系

HashMap 和 HashSet 即 java 中利用哈希表实现的 Map 和 Set。
java 中使用的是哈希桶方式解决冲突的。
java 会在冲突链表长度大于一定阈值后，将链表转变为搜索树（红黑树）。
java 中计算哈希值实际上是调用的类的 hashCode 方法，进行 key 的相等性比较是调用 key 的equals 方法。所以如果要用自定义类作为 HashMap 的 key 或者 HashSet 的值，必须覆写hashCode 和 equals 方法，而且要做到 equals 相等的对象，hashCode 一定是一致的。
针对 TreeSet/TreeMap, key 要求是可比较的（如果传入的 key 是一个类的话，这个类就必须得使用 comparable接口或者 comparator 指定比较规则）；
针对 HashSet/HashMap, key 要求是有 equals 和 hashCode 方法