哈希表题目：设计哈希集合

题目

标题和出处

标题：设计哈希集合

出处：705. 设计哈希集合

难度

3 级

题目描述

要求

不使用任何内建的哈希表库设计一个哈希集合。

实现 $\text{MyHashSet}$ 类：

• $\text{void add(key)}$ 向哈希集合中插入值 $\text{key}$。
• $\text{bool contains(key)}$ 返回哈希集合中是否存在这个值 $\text{key}$。
• $\text{void remove(key)}$ 将给定值 $\text{key}$ 从哈希集合中删除。如果哈希集合中没有这个值，什么也不做。

示例

示例 1：

输入：
$\text{["MyHashSet", "add", "add", "contains", "contains", "add", "contains", "remove", "contains"]}$
$\text{[[], [1], [2], [1], [3], [2], [2], [2], [2]]}$
输出：
$\text{[null, null, null, true, false, null, true, null, false]}$
解释：
$\text{MyHashSet myHashSet = new MyHashSet();}$
$\text{myHashSet.add(1);}$ // $\text{set = [1]}$
$\text{myHashSet.add(2);}$ // $\text{set = [1, 2]}$
$\text{myHashSet.contains(1);}$ // 返回 $\text{True}$
$\text{myHashSet.contains(3);}$ // 返回 $\text{False}$（未找到）
$\text{myHashSet.add(2);}$ // $\text{set = [1, 2]}$
$\text{myHashSet.contains(2);}$ // 返回 $\text{True}$
$\text{myHashSet.remove(2);}$ // $\text{set = [1]}$
$\text{myHashSet.contains(2);}$ // 返回 $\text{False}$（已移除）

数据范围

• $\text{0}\le \text{key}\le {\text{10}}^{\text{6}}$
• 最多调用 ${\text{10}}^{\text{4}}$ 次 $\text{add}$、$\text{remove}$ 和 $\text{contains}$

解法一

思路和算法

由于 $\text{key}$ 的取值范围是 $[0,10^6]$，因此可以创建长度为 $10^6+1$ 的布尔型数组表示哈希集合，数组中的下标为 $\text{key}$ 的元素值表示 $\text{key}$ 是否在哈希集合中。

构造方法中，将数组初始化为长度 $10^6+1$ 的数组，并将数组中的全部元素初始化为 $\text{false}$。

对于 $\text{add}$ 操作，将数组中的下标为 $\text{key}$ 的元素设为 $\text{true}$。

对于 $\text{contains}$ 操作，返回数组中的下标为 $\text{key}$ 的元素。

对于 $\text{remove}$ 操作，将数组中的下标为 $\text{key}$ 的元素设为 $\text{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(1)$，其中 $C$ 是 $\text{key}$ 的取值范围的元素个数，这道题中 $C=10^6+1$。
  构造方法需要创建长度为 $C$ 的数组并将每个元素设为初始值，时间复杂度是 $O(C)$。
  各项操作只需要对数组中的一个元素赋值或返回元素值，时间复杂度是 $O(1)$。

• 空间复杂度：$O(C)$，其中 $C$ 是 $\text{key}$ 的取值范围的元素个数，这道题中 $C=10^6+1$。需要创建长度为 $C$ 的数组表示哈希集合。

解法二

思路和算法

哈希集合的常见实现方法是链表数组，数组的每个下标对应哈希函数可以映射到的索引，当出现哈希冲突时，使用链地址法解决哈希冲突。

用 $\text{BASE}$ 表示链表数组的长度，则可以使用一个简单的哈希函数：$\text{hash}(x)=x\mathrm{mod}\text{BASE}$，每个键经过哈希函数映射之后的值一定在范围 $[0,\text{BASE}-1]$ 内。为了将哈希函数的值尽可能均匀分布，降低哈希冲突的频率，链表数组的长度应选择质数。此处取链表数组的长度为 $1013$。

构造方法中，将链表数组初始化为长度 $\text{BASE}$ 的链表数组，并将链表数组中的全部元素初始化为空链表。

对于各项操作，首先计算 $\text{key}$ 对应的哈希值，得到链表数组的下标，根据下标在链表数组中得到相应的链表，然后在链表中执行相应操作。

对于 $\text{add}$ 操作，在链表数组中得到相应的链表之后，遍历链表，如果遇到元素 $\text{key}$ 则不执行任何操作直接返回，如果遍历结束没有遇到元素 $\text{key}$ 则在链表末尾添加元素 $\text{key}$。

对于 $\text{contains}$ 操作，在链表数组中得到相应的链表之后，遍历链表，如果遇到元素 $\text{key}$ 则返回 $\text{true}$，如果遍历结束没有遇到元素 $\text{key}$ 则返回 $\text{false}$。

对于 $\text{remove}$ 操作，在链表数组中得到相应的链表之后，遍历链表，如果遇到元素 $\text{key}$ 则将其删除，如果遍历结束没有遇到元素 $\text{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(\text{BASE})$，各项操作的时间复杂度都是 $O\left(\frac{n}{\text{BASE}}\right)$，其中 $n$ 是哈希集合中的元素个数，$\text{BASE}$ 是链表数组的长度。
  构造方法需要创建长度为 $\text{BASE}$ 的数组并将每个元素设为初始值，时间复杂度是 $O(\text{BASE})$。
  各项操作需要根据哈希函数计算哈希值，然后遍历链表。计算哈希值需要 $O(1)$ 的时间，假设哈希值分布均匀，每个链表的平均长度是 $O\left(\frac{n}{\text{BASE}}\right)$，因此需要 $O\left(\frac{n}{\text{BASE}}\right)$ 的时间遍历哈希表。

• 空间复杂度：$O(n+\text{BASE})$，其中 $n$ 是哈希集合中的元素个数，$\text{BASE}$ 是链表数组的长度。存储 $n$ 个元素需要 $O(n)$ 的空间，链表数组需要 $O(\text{BASE})$ 的空间。