数据结构：哈希表_一个简单的哈希表

 你受的苦，吃的亏，担的责，扛的罪，忍的痛，到最后都会变成光，照亮你的路。
1

什么是哈希表？

哈希表（Hash table，散列），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做哈希函数，存放记录的数组叫做哈希表。

举个栗子：

一个班有30名学生，他们的学号是1-30的，我们用数组来存储这些学生：

事实上，这个数组就是一个哈希表，班里每个学生的学号都对应了数组中的一个下标。

具体的对应关系为 ： 下标 = 学号 - 1

而 f(key) = value，给定一个键值，计算得到一个地址，这样的关系函数就是哈希函数。

在这个具体的例子中， 下标 = 学号 - 1 就是哈希函数，给定一个学号，就能知道这个学生在数组中的存储位置。这样的话，想要查询一个学生的信息只需要O(1)的时间复杂度！

当然这是一种最为简单的哈希表，想要使用哈希表的方法进行查找，就必须解决下面两个问题：

• Hash函数的构建
• Hash冲突的解决方式

所谓的Hash冲突是指不同的key通过Hash函数所求的地址值value相同，则这些key就产生了Hash冲突

Hash函数的构建方法

哈希表之所以能达到O(1)的复杂度，本质上是以空间换时间。如果空间足够大，相应的我们就能在O(1)的复杂度下完成各项操作，而如果只有O(1)的空间，那么就需要O(n) （线性表）的时间复杂度。

Hash表就是时间和空间之间的平衡，因此Hash函数的构建是非常重要的。通常应该遵循下列原则：

• 高效性：hash函数本身运算尽量简单，便与运算
• 一致性：若a = b ，则 hash(a）= hash(b)
• 均匀性：通过Hash函数得到的hash函数值必须在Hash地址范围内，且分布均匀，地址冲突尽量小

在上一个学号的例子中，我们直接以 下标 = 学号 - 1 的方式，很快的完成了Hash函数的构建，但事实上不是所有的问题都可以如此简单的构建出来，下面就来讨论更复杂的情况下如何构建Hash函数。

1. 大整数：除留余数法
   在我国，居民身份证号是由18位数字组成的，比如：110323198512166666。
   哈希表充分体现了空间换时间的思想，如果我们真的有9999999999999999999个空间，那么我们完全可以从下标为0开始存放，当然这是不切实际的，而且如果真的这样做，也是对空间的极大浪费。对于较大的整数，并且这个整数的每几位还存在某些含义时，我们处理方法是模以一个素数。

下面给出了大整数在lwr-upr之间的最佳取模的素数：或者点击这个链接–>最佳取模的素数

之所以模以一个素数，是因为模以一个素数可以减少hash冲突并且能较为充分地利用到大整数的每部分数据。

比如：

在模以4时产生了严重的Hash冲突，而模以素数7在这组数据中没有发生Hash冲突。

2. 特殊类型构建Hash函数
   对于特殊类型的数据，我们依然是将其转化为整数：比如字符串
   

根据实际需求，我们也可以将字符串转化成B进制的整数。那么hash函数就是这样的：

上面三个hash函数是等价的，只是在第一个hash函数下简化了计算而已。

Hash冲突解决方法

由于具体问题的复杂性，Hash冲突不可避免的存在，因此就需要对Hash冲突进行处理，通常较好的方式是：链地址法。

例如通过Hash函数计算得到 k1的地址为4，k2的地址为1，分别插入后又来了一个k3且地址也是1，此时k1和k3发生了冲突，如何处理呢？

链地址法就是让发生冲突的元素以链表插在前一个元素后面：

事实上发生冲突时并不一定要构成一个链表，只要是查找表就行，也就是说我们完全可以链接一个AVL树或者红黑树。

在Java中HashMap就是TreeMap的数组；HashSet是TreeSet的数组。

基于TreeMap实现HashMap

package cn.boom.hash;

import java.util.Arrays;
import java.util.TreeMap;

public class HashTable<K, V> {

    //取模的素数
    private static int[] prime = {53,97,193,389,769,1543,3079,6151,12289,
                                  24593,49157,98317,196613,393241,786433,
                                  1572869,3145739,6291469,12582917,25165843,
                                  50331653,100663319,201326611,402653189,805306457,1610612741};

    private static final int upperTol = 10; //平均hash冲突上界
    private static final int lowerTol = 2; //平均hash冲突下界

    private TreeMap<K,V>[] hashTable;
    private int capacity;
    private int size;
    private int capacityIndex;

    public HashTable(){

        this.size = 0;
        this.capacityIndex = 0;
        this.capacity = prime[capacityIndex];
        this.hashTable = new TreeMap[capacity];

        for (int i = 0; i < capacity; i++) {
            hashTable[i] = new TreeMap<K, V>();
        }
    }

    public int getSize() {
        return size;
    }

    public boolean contains(K key) {
        int address = hash(key);
        return hashTable[address].containsKey(key);
    }

    //hash函数
    private int hash(K key) {
        return key.hashCode() & 0x7fffffff % capacity;//取key hashCode的正值并计算hash值
    }

    private void resize(int newCapacity){

        TreeMap<K, V>[] newHashTable = new TreeMap[newCapacity];
        for(int i = 0 ; i < newCapacity ; i ++)
            newHashTable[i] = new TreeMap<K,V>();

        int oldCapacity = this.capacity;
        this.capacity = newCapacity;

        for(int i = 0 ; i < oldCapacity ; i ++)
            for(K key: hashTable[i].keySet())
                newHashTable[hash(key)].put(key, hashTable[i].get(key));

        this.hashTable = newHashTable;
    }


    public void add(K key, V value) {

        int address = hash(key);

        if (hashTable[address].containsKey(key)) {
            hashTable[address].put(key, value);
        } else {
            hashTable[address].put(key, value);
            this.size++;

            if (this.size  >= this.capacity * upperTol && capacity+1 < prime.length) {
                resize(prime[(capacityIndex++)]);
            }

        }
    }

    public V remove(K key) {

        int address = hash(key);

        if (!hashTable[address].containsKey(key)) {
            throw new IllegalArgumentException(key + " doesn't exist ! ");
        }

        V ret = hashTable[address].remove(key);
        size--;

        if (this.size < this.capacity * lowerTol && capacityIndex - 1 >= 0) {
            resize(prime[(capacityIndex--)]);
        }

        return ret;
    }

    @Override
    public String toString() {
        return "HashTable{" +
                "hashTable=" + Arrays.toString(hashTable) +
                ", capacity=" + capacity +
                ", size=" + size +
                ", capacityIndex=" + capacityIndex +
                '}';
    }
}

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110