【数据结构】哈希表

概念

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

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

当向该结构中：

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

该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(HashTable)(或者称散列表)

例如：数据集合{1，7，6，4，5，9}；

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

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

问题：按照上述哈希方式，向集合中插入元素 44，会出现什么问题？

• 此时两个 44 和 4 使用相同的哈希函数 key % capacity ==> index，得到的 index 下标是一样的，这种情况就叫哈希冲突

哈希冲突

不同关键字通过相同哈希数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。

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

避免冲突

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

合理设计哈希函数

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

哈希函数设计原则：

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

常见哈希函数

1. 直接定制法–(常用)

取关键字的某个线性函数为散列地址：Hash(Key)= A * Key + B

• 优点：简单、均匀
• 缺点：需要事先知道关键字的分布情况使用场景：适合查找比较小且连续的情况

面试题：

字符串中第一个只出现一次字符

2. 除留余数法–(常用)

设散列表中允许的地址数为 m，取一个不大于 m，但最接近或者等于 m 的质数 p 作为除数，按照哈希函数：

Hash(key) = key% p(p<=m)，将关键码转换成哈希地址

3. 平方取中法–(了解)

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

4. 折叠法–(了解)

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

折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况

5. 随机数法–(了解)

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

通常应用于关键字长度不等时采用此法

6. 数学分析法–(了解)

设有 n 个 d 位数，每一位可能有 r 种不同的符号，这 r 种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。例如：

假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前7位都是相同的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现冲突，还可以对抽取出来的数字进行反转(如 1234 改成 4321)、右环位移(如 1234 改成 4123)、左环移位、前两数与后两数叠加(如 1234 改成 12+34=46)等方法。

数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况

注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突

负载因子调节

散列表的载荷因子定义为： α = 填入表中的元素个数 / 散列表的长度 α=填入表中的元素个数/散列表的长度 α=填入表中的元素个数/散列表的长度

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

α 是散列表装满程度的标志因子。由于表长是定值，α 与“填入表中的元素个数”成正比

• 所以，α 越大，表明填入表中的元素越多，产生冲突的可能性就越大
• 反之，α 越小，表明填入表中的元素越少，产生冲突的可能性就越小
  实际上，散列表的平均查找长度是载荷因子 α 的函数，只是不同处理冲突的方法有不同的函数

对于开放定址发，载荷因子是特别重要的因素，应严格限制在 0.7-0.8 以下。超过 0.8，查表时 CPU 缓存不命中（cachemissing）按照指数曲线上升。因此，一些采用开放定址法的 hash 库，如 Java 的系统库限制了载荷因子为 0.75，超过此值将 resize 散列表

解决冲突

解决哈希冲突两种常见的方法是：闭散列 和 开散列

闭散列

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

1. 线性探测

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

• 通过哈希函数获取待插入元素在哈希表中的位置
• 如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素
• 采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素 4，如果直接删除掉，14 查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。

缺点：

• 有可能会让冲突的元素集中在一个地方

2. 二次探测

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

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

开散列/哈希桶

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

• 链表长度不会太长，是一个常数
• 当数组长度 >= 64，并且链表长度 >= 8 的时候，这个链表就会变成红黑树，效率就又提高了

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

实现一个简单的哈希桶

public class HashBuck {  
     
    static class Node {  
        public int key;  
        public int val;  
        public Node next;  
        public Node(int key, int val) {  
            this.key = key;  
            this.val = val;  
        }  
    }  
    public Node[] array;  
    public int usedSize;  
  
    public double loadFactor = 0.75;  
  
    public HashBuck() {  
        array = new Node[10];  
    }  
  
    public void put(int key,int val) {  
        int index = key % array.length;  
        Node cur = array[index];  
        //1. 遍历当前链表 是否存在当前值  
        while (cur != null) {  
            if(cur.key == key) {  
                cur.val = val;  
                return;  
            }  
            cur = cur.next;  
        }  
        //2. 说明 没有当前值，此时进行 头插  
        Node node = new Node(key,val);  
        node.next = array[index];  
        array[index] = node;  
        usedSize++;  
        //3.  
        if(loadFactorCount() >= loadFactor) {  
            //扩容了  
            resize();  
        }  
    }  
    private void resize() {  
        Node[] newArray = new Node[array.length*2];  
        for (int i = 0; i < array.length; i++) {  
            Node cur = array[i];  
            //开始遍历链表  
            while (cur != null) {  
                int newIndex = cur.key%newArray.length;  
                //把数据存放在新的数组的 newIndex位置  
                Node curN = cur.next;  
                cur.next = newArray[newIndex];  
                newArray[newIndex] = cur;  
                cur = curN;  
            }  
        }  
        array = newArray;  
    }  
  
    private double loadFactorCount() {  
        return usedSize*1.0 / array.length;  
    }  
  
    public int get(int key) {  
        int index = key % array.length;  
        Node cur = array[index];  
        //1. 遍历当前链表 是否存在当前值  
        while (cur != null) {  
            if(cur.key == key) {  
                return cur.val;  
            }  
            cur = cur.next;  
        }  
        return -1;  
    }  
}