数据结构--哈希表

1. 哈希表

1.1 什么是哈希表?

哈希表是基于数组衍生出来的,哈希表高效的核心奥秘是数组的随机访问能力.

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

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。

如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

若判断元素是否存在数组中?
就拿着该元素去判定数组该位置元素是否为 true, 如果为 true 说明存在.~~ 时间复杂度:O(1))

1.2 哈希表引入

如果数字本身较大, 就可以让数字和下标之间建立一个映射关系, 例如数字本身 -1000 再作为下标~

映射关系不一定是简单的 + -, 也可以是更为复杂的数学变换~~

• 插入元素
  根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
• 搜索元素
  对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功

2. 哈希冲突

在选取简单的 % 映射, 此时发现很容易出现两个不同的 key, 映射到同一个位置上~~

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

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

3. 哈希冲突-避免

引起哈希冲突的一个原因可能是：哈希函数设计不够合理。
哈希函数设计原则：
1)哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
2)哈希函数计算出来的地址能均匀分布在整个空间中
3)哈希函数应该比较简单

注意: 我们构造更复杂的映射~~, 能够降低冲突, 但很难消除冲突(冲突是客观存在的)

3.1 闭散列

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

比散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

3.2 开散列

开散列: 如果出现 hash 冲突, 就直接让冲突位置变成链表即可~~

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

3.3 负载因子

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

负载因子如何确定?

• 最好是实际的场景, 具体实验
• 选取不同的负载因子, 在运行效率和占用空间上找一个平衡点~~
• 负载因子越大, 越可能影响效率(链表越长)
• 负载因子越小, 越可能浪费空间~

4. 哈希表实现

class HashNode {
    int key;
    int value;
    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;

    // 将 key 映射成数组下标
    private int hashCode(int key) {
        return key % array.length;
    }
    //
    public void put(int key, int value) {
        // 现根据 key, 计算出下标
        int index = hashCode(key);
        // 判断 key 是否在 hash 表中存在
        // 若存在, 直接修改 value ,不存在就直接插入新节点
        for (HashNode cur = array[index]; cur != null; cur = cur.next) {
            if (cur.key == key) {
                // 找到相同元素, 直接修改 value
                cur.value = value;
                return;
            }
        }
        // 循环结束, 未找到 key ,就需要创建新的节点插入到链表上(头插)
        HashNode newNode = new HashNode(key, value);
        newNode.next = array[index];
        array[index] = newNode;
        size++;

        // 如果持续插入, 就会导致冲突概率越大, 链表长度越长
        // 就会影响到后续操作效率, 就可以扩容
        // 负载因子 = 元素个数 / 数组长度
        // Java 标准库中为 0.75, 但一般是根据实际情况设置
        if (loadFactor() > 0.75) {
            // 效率低下
            resize();
        }
    }

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

    private void resize() {
        // 创建一个大数组, 将元素复制过去
        HashNode[] newArray = new HashNode[array.length * 2];
        // 遍历旧 hash 表, 进行复制
        for (int i = 0; i < array.length; i++) {
            HashNode next = null;
            for (HashNode cur = array[i]; cur != null; cur = cur.next) {
                next = cur.next;
                int newIndex = cur.key % newArray.length;
                // 将 cur 对应节点插入新数组
                cur.next = newArray[newIndex];
                newArray[newIndex] = cur;
            }
        }
        array = newArray;
    }

    public Integer get(int key) {
        int index = hashCode(key);
        // 遍历对应的链表
        for (HashNode cur = array[index]; cur != null; cur = cur.next) {
            if (cur.key == key) {
                return cur.value;
            }
        }
        return null;
    }

    public void remove(int key) {
        int index = hashCode(key);
        // 遍历链表, 本质链表删除
        HashNode prev = null;
        HashNode cur = array[index];
        while (cur != null) {
            if (cur.key == key) {
                prev.next = cur.next;
                size--;
                return;
            }
            prev = cur;
        }
    }

}

5. 性能分析

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

6. 类集关系

1. HashMap 和 HashSet 即 java 中利用哈希表实现的 Map 和 Set
2. java 中使用的是哈希桶方式解决冲突的
3. java 会在冲突链表长度大于一定阈值后，将链表转变为搜索树（红黑树）
4. TreeMap 要求 key 必须可以进行比较, HashMap 要求 key 必须提供 equals 和 hashCode 方法