题目

标题和出处

标题：设计哈希映射

出处：706. 设计哈希映射

难度

3 级

题目描述

要求

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

实现 $\text{MyHashMap}$ 类：

• $\text{MyHashMap()}$ 用空映射初始化对象。
• $\text{void put(int key, int value)}$ 向哈希映射插入一个键值对 $\text{(key, value)}$。如果 $\text{key}$ 已经存在于映射中，则更新其对应的值 $\text{value}$。
• $\text{int get(int key)}$ 返回特定的 $\text{key}$ 所映射的 $\text{value}$；如果映射中不包含 $\text{key}$ 的映射，返回 $\text{-1}$。
• $\text{void remove(key)}$ 如果映射中存在 $\text{key}$ 的映射，则移除 $\text{key}$ 和它所对应的 $\text{value}$。

示例

示例 1：

输入：
$\text{["MyHashMap", "put", "put", "get", "get", "put", "get", "remove", "get"]}$
$\text{[[], [1, 1], [2, 2], [1], [3], [2, 1], [2], [2], [2]]}$
输出：
$\text{[null, null, null, 1, -1, null, 1, null, -1]}$
解释：
$\text{MyHashMap myHashMap = new MyHashMap();}$
$\text{myHashMap.put(1, 1);}$ // $\text{myHashMap}$ 现在为 $\text{[[1,1]]}$
$\text{myHashMap.put(2, 2);}$ // $\text{myHashMap}$ 现在为 $\text{[[1,1], [2,2]]}$
$\text{myHashMap.get(1);}$ // 返回 $\text{1}$，$\text{myHashMap}$ 现在为 $\text{[[1,1], [2,2]]}$
$\text{myHashMap.get(3);}$ // 返回 $\text{-1}$（未找到），$\text{myHashMap}$ 现在为 $\text{[[1,1], [2,2]]}$
$\text{myHashMap.put(2, 1);}$ // $\text{myHashMap}$ 现在为 $\text{[[1,1], [2,1]]}$（更新已有的值）
$\text{myHashMap.get(2);}$ // 返回 $\text{1}$，$\text{myHashMap}$ 现在为 $\text{[[1,1], [2,1]]}$
$\text{myHashMap.remove(2);}$ // 删除键为 $\text{2}$ 的数据，$\text{myHashMap}$ 现在为 $\text{[[1,1]]}$
$\text{myHashMap.get(2);}$ // 返回 $\text{-1}$（未找到），$\text{myHashMap}$ 现在为 $\text{[[1,1]]}$

数据范围

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

前言

这道题和「设计哈希集合」非常相似，区别在于这道题存储的不是 $\text{key}$ 本身，而是 $(\text{key},\text{value})$ 的键值对。这道题也可以使用「设计哈希集合」的解法。

解法一

思路和算法

由于 $\text{key}$ 和 $\text{value}$ 的取值范围是 $[0,10^6]$，因此可以创建长度为 $10^6+1$ 的整型数组表示哈希表，数组中的下标为 $\text{key}$ 的元素值表示 $\text{key}$ 映射的 $\text{value}$，$\text{value}\ge 0$ 表示存在 $\text{key}$ 的映射，$\text{value}<0$ 表示不存在 $\text{key}$ 的映射，当 $\text{value}<0$ 时一定有 $\text{value}=-1$。

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

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

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

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

需要说明的是，该解法虽然实现简单，但是不适合在面试中使用。

代码

class MyHashMap {int[] map;public MyHashMap() {map = new int[1000001];Arrays.fill(map, -1);}public void put(int key, int value) {map[key] = value;}public int get(int key) {return map[key];}public void remove(int key) {map[key] = -1;}
}

复杂度分析

• 时间复杂度：构造方法的时间复杂度是 $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{put}$ 操作，在链表数组中得到相应的链表之后，遍历链表，如果遇到元素的键等于 $\text{key}$ 则将元素的值设为 $\text{value}$ 并直接返回，如果遍历结束没有遇到元素的键等于 $\text{key}$ 则在链表末尾添加元素 $(\text{key},\text{value})$。

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

对于 $\text{remove}$ 操作，在链表数组中得到相应的链表之后，遍历链表，如果遇到元素的键等于 $\text{key}$ 则将其删除，如果遍历结束没有遇到元素的键等于 $\text{key}$ 则不执行任何操作。

实现方面，为了提升运行效率，使用迭代器遍历链表和执行删除操作。

代码

class MyHashMap {private class Entry {private int key;private int value;public Entry(int key, int value) {this.key = key;this.value = value;}public int getKey() {return key;}public int getValue() {return value;}public void setValue(int value) {this.value = value;}}private static final int BASE = 1013;private LinkedList<Entry>[] map;public MyHashMap() {map = new LinkedList[BASE];for (int i = 0; i < BASE; i++) {map[i] = new LinkedList<Entry>();}}public void put(int key, int value) {int index = key % BASE;LinkedList<Entry> list = map[index];Iterator<Entry> iterator = list.iterator();while (iterator.hasNext()) {Entry entry = iterator.next();if (entry.getKey() == key) {entry.setValue(value);return;}}list.offerLast(new Entry(key, value));}public int get(int key) {int index = key % BASE;LinkedList<Entry> list = map[index];Iterator<Entry> iterator = list.iterator();while (iterator.hasNext()) {Entry entry = iterator.next();if (entry.getKey() == key) {return entry.getValue();}}return -1;}public void remove(int key) {int index = key % BASE;LinkedList<Entry> list = map[index];Iterator<Entry> iterator = list.iterator();while (iterator.hasNext()) {Entry entry = iterator.next();if (entry.getKey() == key) {iterator.remove();break;}}}
}

复杂度分析

• 时间复杂度：构造方法的时间复杂度是 $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})$ 的空间。