标题:设计哈希集合
出处:705. 设计哈希集合
3 级
不使用任何内建的哈希表库设计一个哈希集合。
实现 MyHashSet \texttt{MyHashSet} MyHashSet 类:
示例 1:
输入:
["MyHashSet", "add", "add", "contains", "contains", "add", "contains", "remove", "contains"] \texttt{["MyHashSet", "add", "add", "contains", "contains", "add", "contains", "remove", "contains"]} ["MyHashSet", "add", "add", "contains", "contains", "add", "contains", "remove", "contains"]
[[], [1], [2], [1], [3], [2], [2], [2], [2]] \texttt{[[], [1], [2], [1], [3], [2], [2], [2], [2]]} [[], [1], [2], [1], [3], [2], [2], [2], [2]]
输出:
[null, null, null, true, false, null, true, null, false] \texttt{[null, null, null, true, false, null, true, null, false]} [null, null, null, true, false, null, true, null, false]
解释:
MyHashSet myHashSet = new MyHashSet(); \texttt{MyHashSet myHashSet = new MyHashSet();} MyHashSet myHashSet = new MyHashSet();
myHashSet.add(1); \texttt{myHashSet.add(1);} myHashSet.add(1); // set = [1] \texttt{set = [1]} set = [1]
myHashSet.add(2); \texttt{myHashSet.add(2);} myHashSet.add(2); // set = [1, 2] \texttt{set = [1, 2]} set = [1, 2]
myHashSet.contains(1); \texttt{myHashSet.contains(1);} myHashSet.contains(1); // 返回 True \texttt{True} True
myHashSet.contains(3); \texttt{myHashSet.contains(3);} myHashSet.contains(3); // 返回 False \texttt{False} False(未找到)
myHashSet.add(2); \texttt{myHashSet.add(2);} myHashSet.add(2); // set = [1, 2] \texttt{set = [1, 2]} set = [1, 2]
myHashSet.contains(2); \texttt{myHashSet.contains(2);} myHashSet.contains(2); // 返回 True \texttt{True} True
myHashSet.remove(2); \texttt{myHashSet.remove(2);} myHashSet.remove(2); // set = [1] \texttt{set = [1]} set = [1]
myHashSet.contains(2); \texttt{myHashSet.contains(2);} myHashSet.contains(2); // 返回 False \texttt{False} False(已移除)
由于 key \textit{key} key 的取值范围是 [ 0 , 1 0 6 ] [0, 10^6] [0,106],因此可以创建长度为 1 0 6 + 1 10^6 + 1 106+1 的布尔型数组表示哈希集合,数组中的下标为 key \textit{key} key 的元素值表示 key \textit{key} key 是否在哈希集合中。
构造方法中,将数组初始化为长度 1 0 6 + 1 10^6 + 1 106+1 的数组,并将数组中的全部元素初始化为 false \text{false} false。
对于 add \textit{add} add 操作,将数组中的下标为 key \textit{key} key 的元素设为 true \text{true} true。
对于 contains \textit{contains} contains 操作,返回数组中的下标为 key \textit{key} key 的元素。
对于 remove \textit{remove} remove 操作,将数组中的下标为 key \textit{key} key 的元素设为 false \text{false} false。
需要说明的是,该解法虽然实现简单,但是不适合在面试中使用。
class MyHashSet {
boolean[] set;
public MyHashSet() {
set = new boolean[1000001];
Arrays.fill(set, false);
}
public void add(int key) {
set[key] = true;
}
public void remove(int key) {
set[key] = false;
}
public boolean contains(int key) {
return set[key];
}
}
时间复杂度:构造方法的时间复杂度是 O ( C ) O(C) O(C),各项操作的时间复杂度都是 O ( 1 ) O(1) O(1),其中 C C C 是 key \textit{key} key 的取值范围的元素个数,这道题中 C = 1 0 6 + 1 C = 10^6 + 1 C=106+1。
构造方法需要创建长度为 C C C 的数组并将每个元素设为初始值,时间复杂度是 O ( C ) O(C) O(C)。
各项操作只需要对数组中的一个元素赋值或返回元素值,时间复杂度是 O ( 1 ) O(1) O(1)。
空间复杂度: O ( C ) O(C) O(C),其中 C C C 是 key \textit{key} key 的取值范围的元素个数,这道题中 C = 1 0 6 + 1 C = 10^6 + 1 C=106+1。需要创建长度为 C C C 的数组表示哈希集合。
哈希集合的常见实现方法是链表数组,数组的每个下标对应哈希函数可以映射到的索引,当出现哈希冲突时,使用链地址法解决哈希冲突。
用 BASE \textit{BASE} BASE 表示链表数组的长度,则可以使用一个简单的哈希函数: hash ( x ) = x m o d BASE \text{hash}(x) = x \bmod \textit{BASE} hash(x)=xmodBASE,每个键经过哈希函数映射之后的值一定在范围 [ 0 , BASE − 1 ] [0, \textit{BASE} - 1] [0,BASE−1] 内。为了将哈希函数的值尽可能均匀分布,降低哈希冲突的频率,链表数组的长度应选择质数。此处取链表数组的长度为 1013 1013 1013。
构造方法中,将链表数组初始化为长度 BASE \textit{BASE} BASE 的链表数组,并将链表数组中的全部元素初始化为空链表。
对于各项操作,首先计算 key \textit{key} key 对应的哈希值,得到链表数组的下标,根据下标在链表数组中得到相应的链表,然后在链表中执行相应操作。
对于 add \textit{add} add 操作,在链表数组中得到相应的链表之后,遍历链表,如果遇到元素 key \textit{key} key 则不执行任何操作直接返回,如果遍历结束没有遇到元素 key \textit{key} key 则在链表末尾添加元素 key \textit{key} key。
对于 contains \textit{contains} contains 操作,在链表数组中得到相应的链表之后,遍历链表,如果遇到元素 key \textit{key} key 则返回 true \text{true} true,如果遍历结束没有遇到元素 key \textit{key} key 则返回 false \text{false} false。
对于 remove \textit{remove} remove 操作,在链表数组中得到相应的链表之后,遍历链表,如果遇到元素 key \textit{key} key 则将其删除,如果遍历结束没有遇到元素 key \textit{key} key 则不执行任何操作。
实现方面,为了提升运行效率,使用迭代器遍历链表和执行删除操作。
class MyHashSet {
private static final int BASE = 1013;
private LinkedList<Integer>[] set;
public MyHashSet() {
set = new LinkedList[BASE];
for (int i = 0; i < BASE; i++) {
set[i] = new LinkedList<Integer>();
}
}
public void add(int key) {
int index = key % BASE;
LinkedList<Integer> list = set[index];
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
Integer element = iterator.next();
if (element == key) {
return;
}
}
list.offerLast(key);
}
public void remove(int key) {
int index = key % BASE;
LinkedList<Integer> list = set[index];
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
Integer element = iterator.next();
if (element == key) {
iterator.remove();
break;
}
}
}
public boolean contains(int key) {
int index = key % BASE;
LinkedList<Integer> list = set[index];
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
Integer element = iterator.next();
if (element == key) {
return true;
}
}
return false;
}
}
时间复杂度:构造方法的时间复杂度是 O ( BASE ) O(\textit{BASE}) O(BASE),各项操作的时间复杂度都是 O ( n BASE ) O\Big(\dfrac{n}{\textit{BASE}}\Big) O(BASEn),其中 n n n 是哈希集合中的元素个数, BASE \textit{BASE} BASE 是链表数组的长度。
构造方法需要创建长度为 BASE \textit{BASE} BASE 的数组并将每个元素设为初始值,时间复杂度是 O ( BASE ) O(\textit{BASE}) O(BASE)。
各项操作需要根据哈希函数计算哈希值,然后遍历链表。计算哈希值需要 O ( 1 ) O(1) O(1) 的时间,假设哈希值分布均匀,每个链表的平均长度是 O ( n BASE ) O\Big(\dfrac{n}{\textit{BASE}}\Big) O(BASEn),因此需要 O ( n BASE ) O\Big(\dfrac{n}{\textit{BASE}}\Big) O(BASEn) 的时间遍历哈希表。
空间复杂度: O ( n + BASE ) O(n + \textit{BASE}) O(n+BASE),其中 n n n 是哈希集合中的元素个数, BASE \textit{BASE} BASE 是链表数组的长度。存储 n n n 个元素需要 O ( n ) O(n) O(n) 的空间,链表数组需要 O ( BASE ) O(\textit{BASE}) O(BASE) 的空间。