[数据结构] 哈希表

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

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

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

冲突-避免-负载因子调节(重点掌握)

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

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

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

所以，α 越大，表明填入表中的元素越多，产生冲突的可能性就越大
反之，α 越小，表明填入表中的元素越少，产生冲突的可能性就越小

实际上，散列表的平均查找长度是载荷因子 α 的函数，只是不同处理冲突的方法有不同的函数

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

冲突-解决-闭散列

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

1.线性探测

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

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

插入

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

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

2.二次探测

线性探测的缺点是产生冲突的数据堆积在一起, 这与其找下一个空位置有关系, 因为找空位置的方式就是挨着往后逐个去找, 因此二次探测为了避免该问题, 找下一个空位置的方法为:%m,或者: % m .其中, i = 1, 2, 3...,H0是通过散列函数Hash(x)对元素的关键码key进行计算得到的位置,m是表的大小.对于上面的插入44,产生冲突,使用解决后的情况为:

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

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

冲突-解决-开散列/哈希桶(重点掌握)

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

从上图可以看出, 开散列中每个桶中放的都是发生哈希冲突的元素.

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

哈希冲突严重时的解决办法

刚才我们提到了，哈希桶其实可以看作将大集合的搜索问题转化为小集合的搜索问题了，那如果冲突严重，就意味着小集合的搜索性能其实也时不佳的，这个时候我们就可以将这个所谓的小集合搜索问题继续进行转化，例如：

每个桶的背后是另一个哈希表
每个桶的背后是一棵搜索树

实现

java 复制代码

// key-value 模型
public class HashBucket {
    private static class Node {
        private int key;
        private int value;
        Node next;

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

    private Node[] array;
    private int size; // 当前的数据个数
    private static final double LOAD_FACTOR = 0.75;

    private int put(int key,int value) {
        int index = key % array.length;
        // 在链表中查找key所在的节点
        // 如果找到了,更新
        // 所有节点都不是key, 插入一个新的节点
        for (Node cur =array[index];cur != null;cur = cur.next) {
            if(key == cur.key) {
                int oldValue = cur.value;
                cur.value = value;
                return oldValue;
            }
        }
        Node node = new Node(key,value);
        node.next = array[index];
        array[index] = node;
        size++;
        if (loadFactor() >= LOAD_FACTOR) {
            resize();
        }
        return -1;
    }

    private void resize() {
        Node[] newArray = new Node[array.length * 2];
        for (int i = 0;i < array.length;i++) {
            Node next;
            for(Node cur = array[i];cur != null;cur = next) {
                next = cur.next;
                int index = cur.key % newArray.length;
                cur.next = newArray[index];
                newArray[index] = cur;
            }
        }
        array = newArray;
    }
    private double loadFactor() {
        return size * 1.0 / array.length;
    }
    public HashBucket() {
        array = new Node[8];
        size = 0;
    }

    public int get(int key) {
        int index = key % array.length;
        
        Node head = array[index];
        for(Node cur = head;cur != null;cur = cur.next) {
            if(key == cur.key) {
                return cur.value;
            }
        }
        return -1;
    }
      
}

性能分析

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

[数据结构] 哈希表

概念

冲突-概念

冲突-避免

冲突-避免-哈希函数设计

常见哈希函数

1.直接定制发--(常用)

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

**3.**平方取中法--(了解)

4.折叠法--(了解)

5.数学分析法--(了解)