数据结构 哈希表

数据结构 哈希表

1. 概念

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

理想的搜索方法：

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

当向该结构中：

• 插入元素

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

• 搜索元素

  对元素的关键码进行同样的计数，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功

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

例如：数据集合{1, 7, 6, 4, 5, 9};

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

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

但是，如果按照上述哈希方法向集合中插入元素44，却会出现问题，为什么？往下看

2. 冲突-概念

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

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

3. 冲突-避免

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

3.1 哈希函数设计

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

哈希函数设计原则:

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

常见哈希函数

1. 直接定制法

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

   优点：简单、均匀 缺点：需要事先知道关键字的分布情况

   使用场景：适合查找比较小且连续的情况

   代码示例:

   class Solution {
       public int firstUniqChar(String s) {
           int[] count = new int[26];
           for (int i = 0;i < s.length();i++) {
               count[s.charAt(i) - 97]++;
           }
           for (int i = 0;i < s.length();i++) {
               if (count[s.charAt(i) - 97] == 1) {
                   return i;
               }
           }
           return -1;
       }
      
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15

   

2. 除留余数法

   设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数: Hash(Key) = Key % p(p <= m)，将关键码转换成哈希地址

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

3.2 负载因子调节

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

所以当冲突率达到一个无法忍受的程度时，我们需要通过降低负载因子来变相的降低冲突率

已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组大小

4.冲突-解决

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

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是表的大小。对于2.1中如果要插入44，产生冲突，使用解决后的情况为：

   

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

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

4.2 开散列(哈希桶)

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

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

开散列(哈希桶)，可以认为是把一个在大集合中的搜索问题转化为在小集合中做搜索

当冲突比较严重时，小集合的搜索性能解决效果也不高，这个时候

我们需要将这个所谓的小集合搜索问题继续进行转换，例如：

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

4.3 哈希桶实现

代码示例:

package demo1;

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 static final float DEFAULT_LOAD_FACTOR = 0.75f;

    public HashBuck() {
        array = new Node[10];
    }

    /*插入元素*/
    public void put(int key, int val) {
        int index = key % array.length;
        Node cur = array[index];
        while(cur != null) {
            if (cur.key == key) {
                cur.val = val;
                return;
            }
            cur = cur.next;
        }
        // 遍历完后说明没有找到key元素，利用头插法将元素加进桶中
        Node newNode = new Node(key, val);
        newNode.next = array[index];
        array[index] = newNode;
        usedSize++;

        //若负载因子超过0.75,扩容
        if (doLoadFact() > DEFAULT_LOAD_FACTOR) {
            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) {
                Node temp = cur.next;
                int newIndex = cur.key % newArray.length;
                //采用头插法，将节点插入新数组的newIndex下标中
                cur.next = newArray[newIndex];
                newArray[newIndex] = cur;
                cur = temp;
            }
        }
        array = newArray;
    }

    private float doLoadFact() {
        return usedSize*1.0f / array.length;
    }

    /*获取元素*/
    public int get(int key) {
        int Index = key % array.length;
        Node cur = array[Index];
        while(cur != null) {
            if (cur.key == key) {
                return cur.val;
            }
            cur = cur.next;
        }
        return -1;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

5. 性能分析

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

6. 和java类集的关系

1. HashMap 和 HashSet 是java中利用哈希表实现的Map 和 Set
2. java中使用的是哈希桶方式解决冲突的
3. java会在冲突链表长度大于一定阈值后，将链表转变为搜索树(红黑树)
4. java中计算哈希值实际上是调用的类的hashCode方法，进行key的相等性比较是调用key的equals方法。所以如果要同自定义类作为HashMap的key或者HashSet的值，必须覆写hashCode和equals方法，并且要做到equals相等的对象，hashCode一定是一致的。