【数据结构】HashTable 哈希表_hashtable数据结构

前言

散列表（Hash table，也叫哈希表），使用哈希函数（Hash Function）将键（Key）转换为数组的索引，根据Key value而直接进行访问的数据结构，以此来实现快速的插入、删除和查找操作。它通过把关键码值映射到表中一个位置来访问记录（类似索引），以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

1. 哈希函数：
   哈希函数是一个将任意长度的键转换为固定长度索引的算法。
   理想的哈希函数应该满足以下条件：
   快速计算：哈希函数的计算时间应尽可能短。
   均匀分布：对于不同的键，哈希函数应该产生均匀分布的索引，以减少冲突的可能性。
2. 冲突处理：
   冲突（Collision）是指两个不同的键经过哈希函数计算后得到相同的索引。
   处理冲突的方法有多种，常见的包括开放寻址法（Open Addressing）和链地址法（Chaining）：
   开放寻址法：当发生冲突时，寻找数组中的下一个空闲位置进行存储。这种方法通常会使用线性探测、二次探测或双散列等策略。
   链地址法：在数组的每个位置上存储一个链表，当发生冲突时，新来的元素将被添加到链表的末尾。
3. 操作过程：
   插入：给定一个键值对，首先使用哈希函数计算出键的索引，然后在该索引位置存储值。如果发生冲突，则根据冲突处理策略进行调整。
   查找：给定一个键，使用哈希函数计算出其索引，然后在该索引位置查找对应的值。如果使用链地址法，可能需要遍历链表来找到正确的键值对。
   删除：给定一个键，使用哈希函数计算出其索引，然后在该索引位置删除对应的值。如果使用链地址法，可能需要遍历链表来找到并删除正确的键值对。
4. 性能：
   在理想情况下，哈希表的插入、删除和查找操作的时间复杂度都是O(1)，即常数时间复杂度，这是因为可以直接通过哈希函数计算出键的索引。
   然而，实际情况下，由于冲突的存在，哈希表的性能可能会下降。良好的哈希函数和冲突处理策略能够最大限度地减少冲突，从而保持高效的性能。
5. 应用：
   哈希表在计算机科学中有广泛的应用，包括数据库索引、缓存、集合（如Java中的HashMap和HashSet）等领域。
   总的来说，哈希表是一种基于哈希函数实现的高效数据结构，通过将键映射到数组的索引，实现了快速的插入、删除和查找操作。尽管冲突是哈希表的一个固有问题，但通过精心设计的哈希函数和冲突处理策略，可以有效地管理冲突并保持优秀的性能。

数据结构源码

实现类

我们定义完整的哈希表 HashTable.java

import java.util.TreeMap;

public class HashTable<K, V> {

    private static final int upperTol = 10;

    private static final int lowerTol = 2;

    private static final int initCapacity = 7;

    private TreeMap<K, V>[] hashtable;

    private int M;

    private int size;

    public HashTable(int M) {
        this.M = M;
        size = 0;
        hashtable = new TreeMap[M];
        for (int i = 0; i < M; i++) {
            hashtable[i] = new TreeMap<>();
        }
    }

    public HashTable() {
        this(initCapacity);
    }

    private int hash(K key) {
        return (key.hashCode() & 0x7fffffff) % M;
    }

    public int getSize() {
        return size;
    }

    public void add(K key, V value) {
        TreeMap<K, V> map = hashtable[hash(key)];

        if (!map.containsKey(key)){
            map.put(key, value);
            size ++;

            if(size >= upperTol * M)
                resize(2 * M);
        }
    }

    public V remove(K key) {
        TreeMap<K, V> map = hashtable[hash(key)];
        V ret = null;
        if (map.containsKey(key)) {
            ret = map.remove(key);
            size--;

            if (size < lowerTol * M && M / 2 > 0)
                resize(M / 2);
        }
        return ret;
    }

    public void set(K key, V value) {
        TreeMap<K, V> map = hashtable[hash(key)];
        if (!map.containsKey(key)) {
            throw new IllegalArgumentException(key + " doesn't exist!");
        }
        map.put(key, value);
    }

    public boolean contains(K key) {
        return hashtable[hash(key)].containsKey(key);
    }

    public V get(K key) {
        return hashtable[hash(key)].get(key);
    }

    private void resize(int newM){
        TreeMap<K, V>[] newHashTable = new TreeMap[newM];
        for(int i = 0 ; i < newM ; i ++)
            newHashTable[i] = new TreeMap<>();

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

        this.M = newM;
        this.hashtable = newHashTable;
    }
}
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

数据结构拆解

之后对源码进行数据结构拆解

维护字段和内部类

我们定义维护字段和内部类

private static final int upperTol = 10;

private static final int lowerTol = 2;

private static final int initCapacity = 7;

private TreeMap<K, V>[] hashtable;

private int M;

private int size;
1
2
3
4
5
6
7
8
9
10
11
12

构造函数

定义构造函数：

public HashTable(int M) {
    this.M = M;
    size = 0;
    hashtable = new TreeMap[M];
    for (int i = 0; i < M; i++) {
        hashtable[i] = new TreeMap<>();
    }
}

public HashTable() {
    this(initCapacity);
}
1
2
3
4
5
6
7
8
9
10
11
12

增

public void add(K key, V value) {
    TreeMap<K, V> map = hashtable[hash(key)];

    if (!map.containsKey(key)){
        map.put(key, value);
        size ++;

        if(size >= upperTol * M)
            resize(2 * M);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

删

public V remove(K key) {
    TreeMap<K, V> map = hashtable[hash(key)];
    V ret = null;
    if (map.containsKey(key)) {
        ret = map.remove(key);
        size--;

        if (size < lowerTol * M && M / 2 > 0)
            resize(M / 2);
    }
    return ret;
}
1
2
3
4
5
6
7
8
9
10
11
12

改

public void set(K key, V value) {
    TreeMap<K, V> map = hashtable[hash(key)];
    if (!map.containsKey(key)) {
        throw new IllegalArgumentException(key + " doesn't exist!");
    }
    map.put(key, value);
}
1
2
3
4
5
6
7
8

private void resize(int newM){
    TreeMap<K, V>[] newHashTable = new TreeMap[newM];
    for(int i = 0 ; i < newM ; i ++)
        newHashTable[i] = new TreeMap<>();

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

    this.M = newM;
    this.hashtable = newHashTable;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

查

private int hash(K key) {
    return (key.hashCode() & 0x7fffffff) % M;
}

public int getSize() {
    return size;
}
1
2
3
4
5
6
7

public boolean contains(K key) {
    return hashtable[hash(key)].containsKey(key);
}

public V get(K key) {
    return hashtable[hash(key)].get(key);
}
1
2
3
4
5
6
7
8