算法和数据结构解析-7 : 哈希表相关问题
Posted 鮀城小帅
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了算法和数据结构解析-7 : 哈希表相关问题相关的知识，希望对你有一定的参考价值。
1. 哈希表数据结构概念
1.1 基本概念
哈希表（Hash Table）也叫散列表，是可以根据关键字值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键字值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数（哈希函数），存放记录的数组就叫做散列表。
哈希表里保存的数据元素是一组键-值对（key-value pair），它的特性就是可以根据给出的 key 快速访问 value。
哈希表在不考虑冲突的情况下，插入、删除和访问操作时间复杂度均为O(1)。
1.2 核心问题
设计一个哈希表，有两个核心问题需要去解决：
- 如何设计哈希方法（哈希函数）
- 如何避免哈希碰撞
哈希方法（hash method，也叫哈希函数）会将键值映射到某块存储空间。
一个好的哈希方法，应该将不同的键值，均匀地分布在存储空间中。理想情况下，每个值都应该有一个对应唯一的散列值。
哈希方法要将大量的键值，映射到一个有限的空间里。这样就有可能会将不同的键值，映射到同一个存储空间，这种情况称为 “哈希碰撞” （Hash Collision，也叫“哈希冲突”）。哈希碰撞是不可避免的，但可以用策略来解决哈希碰撞。
为了解决 哈希碰撞 ，我们利用 桶 来存储所有对应的数值。桶可以用 数组 或 链表 来实现（Java中就是用链表来实现的）。
2. 只出现一次的数字
2.1 题目说明
给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
说明：
你的算法应该具有线性时间复杂度。你可以不使用额外空间来实现吗？
示例 1:
输入: [2,2,1]
输出: 1
示例 2:
输入: [4,1,2,1,2]
输出: 4
2.2 分析
这是基于数组的一道题目。
题目中除了一个元素之外，其它都出现两次。所以我们可以想到，只要把元素是否出现过记录下来，遍历完数组就可以判断出单独的那个数了。
2.3 方法一：暴力法
基本想法是，遍历数组，把当前所有出现的单独元素都另外保存下来。遇到重复的就删除。
// 方法一：暴力法
public int singleNumber1(int[] nums)
// 定义一个列表，保存当前所有出现过一次的元素
ArrayList<Integer> singleNumList = new ArrayList<>();
// 遍历所有元素
for (Integer num: nums)
if (singleNumList.contains(num))
// 如果已经出现过，删除列表中的元素
singleNumList.remove(num);
else
// 没有出现过，直接保存
singleNumList.add(num);
return singleNumList.get(0);
复杂度分析
时间复杂度：O(n^2)。我们遍历nums 花费O(n) 的时间；另外我们还要在列表中遍历，判断是否存在这个数字，再花费 O(n) 的时间，所以总循环时间为 O(n^2)。
空间复杂度：O(n)。我们需要一个大小为 n 的列表保存所有的 nums 中元素。
2.4 方法二：保存到HashMap
由于在列表中查询需要耗费线性时间，所以可以想到，可以把数不保存到列表，而是保存到HashMap中，这样查询的时候不就不用再遍历一次了。
// 方法二：保存单独的元素到HashMap
public int singleNumber2(int[] nums)
HashMap<Integer, Integer> singleNumMap = new HashMap<>();
for (Integer num: nums)
if (singleNumMap.get(num) != null)
singleNumMap.remove(num);
else
singleNumMap.put(num, 1);
return singleNumMap.keySet().iterator().next();
复杂度分析
时间复杂度：O(n) 。for 循环的时间复杂度是 O(n)。而HashMap的 get 操作时间复杂度为O(1) 。
空间复杂度：O(n) 。HashMap需要的空间与nums中元素个数相等。
2.5 方法三：保存到set
也可以利用set来进行去重，然后计算set中所有元素的总和。得到的总和乘以2，就是所有元素加了两遍；对比原数组，只多了一个那个落单的数。所以减去原数组的总和，就是要找的那个数。
// 方法三：用set去重，a = 2 * (a+b+c) - (a+b+c+b+c)
public int singleNumber3(int[] nums)
// 定义一个HashSet进行去重
HashSet<Integer> set = new HashSet<>();
int arraySum = 0;
int setSum = 0;
// 1. 遍历数组元素，保存到set，并直接求和
for (int num: nums)
set.add(num);
arraySum += num;
// 2. 集合所有元素求和
for (int num: set)
setSum += num;
// 3. 计算结果
return setSum * 2 - arraySum;
时间复杂度：O(n) 。计算sum和，会将nums中的元素遍历一遍，再将set中的元素遍历一遍。我们可以认为是遍历了两遍。
空间复杂度：O(n) 。HashSet 需要的空间跟 nums 中元素个数一致。
2.6 方法四：位运算
我们回忆一下数学上异或运算的概念：
- 如果对 0 和二进制位做 XOR 运算，得到的仍然是这个二进制位
a⊕0=a
- 如果对相同的二进制位做 XOR 运算，返回的结果是 0
a⊕a=0
- XOR 满足交换律和结合律
a⊕b⊕a=(a⊕a)⊕b=0⊕b=b
所以我们只需要将所有的数进行 XOR 操作，就能得到那个唯一的数字
// 方法四：数学方法（做异或）
public int singleNumber(int[] nums)
int result = 0;
// 遍历所有数据，按位做异或
for (int num: nums)
result ^= num;
return result;
复杂度分析
时间复杂度：O(n)，其中 n 是数组长度。只需要对数组遍历一次。
空间复杂度：O(1)。
3. 最长连续序列
3.1 题目说明
给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。
进阶：你可以设计并实现时间复杂度为 O(n) 的解决方案吗？
示例 1：
输入：nums = [100,4,200,1,3,2]
输出：4
解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。
示例 2：
输入：nums = [0,3,7,2,5,8,4,6,0,1]
输出：9
提示：
- 0 <= nums.length <= 104
- -109 <= nums[i] <= 109
3.2 分析
要寻找连续序列，关键在于找到当前数的“下一个数”（或者叫“后继”）。
如果有后继，就在数组中继续找，每找到一个后继，当前序列长度就加1；直到找不到时，就得到了以当前数开始的、最长的连续序列长度。
3.3 方法一：暴力法
最简单的实现，就是遍历所有数据，对每一数据都找从它开始的最长连续序列。
寻找连续序列，就是要不停寻找后继。而判断后继是否存在，又要在数组中进行遍历寻找。
// 方法一：暴力法
public int longestConsecutiveSequence1(int[] nums)
// 定义一个变量，保存当前最长连续序列的长度
int maxLength = 0;
// 遍历数组，以每个元素作为起始点，寻找连续序列
for (int i = 0; i < nums.length; i++)
// 保存当前元素作为起始点
int currNum = nums[i];
// 保存当前连续序列长度
int currLength = 1;
// 寻找后续数字，组成连续序列
while ( contains(nums, currNum + 1) )
currLength ++;
currNum ++;
// 判断当前连续序列长度是否为最大
maxLength = currLength > maxLength ? currLength : maxLength;
return maxLength;
// 定义一个方法，用于在数组中寻找某个元素
public boolean contains(int[] nums, int x)
for (int num: nums)
if (num == x)
return true;
return false;
复杂度分析
时间复杂度：O(N^3)。我们定义了外层循环遍历数组，内层循环不停寻找后继；另外，在内层循环中每次要判断后继是否存在，还需要遍历数组查找。所以总计是O(N^3)。
空间复杂度：O(1)。过程中只用到了一些辅助的临时变量。
3.4 方法二：哈希表改进
用哈希表（Hash Set）来保存数组中的元素，可以快速判断元素是否存在。这样contains可以优化为常数时间复杂度。
// 方法二：利用哈希表改进
public int longestConsecutiveSequence2(int[] nums)
// 定义一个变量，保存当前最长连续序列的长度
int maxLength = 0;
// 定义一个HashSet，保存所有出现的数值
HashSet<Integer> hashSet = new HashSet<>();
// 1. 遍历所有元素，保存到HashSet
for (int num: nums)
hashSet.add(num);
// 2. 遍历数组，以每个元素作为起始点，寻找连续序列
for (int i = 0; i < nums.length; i++)
// 保存当前元素作为起始点
int currNum = nums[i];
// 保存当前连续序列长度
int currLength = 1;
// 寻找后续数字，组成连续序列
while ( hashSet.contains(currNum + 1) )
currLength ++;
currNum ++;
// 判断当前连续序列长度是否为最大
maxLength = currLength > maxLength ? currLength : maxLength;
return maxLength;
复杂度分析
时间复杂度：O(N^2)。将数组元素保存入Hash Set需要。后面由于简化了内层循环中判断后继的过程，只耗费O(1)时间，所以最终是内外两重循环，最坏情况下时间复杂度为O(N^2)。
空间复杂度：O(N)。我们用到了一个Hash Set来保存数组元素，排除部分重复数据，这仍然需要耗费O(N)的内存空间。
3.5 方法三：哈希表进一步优化
仔细分析上面的算法过程，我们会发现其中执行了很多不必要的枚举。
例如，我们已经寻找过x开始的连续序列，已知有一个 x,x+1,x+2,⋯,x+y 的连续序列。现在要继续寻找x+1开始的连续序列，算法会重新寻找它的后继x+2，而这个过程我们已经做过了。
并且，我们可以确定，这种情况得到的结果（连续序列的长度），肯定不会优于以x 为起点的答案。因此这部分处理完全没有必要，我们在外层循环的时候碰到这种情况，直接跳过即可。
// 方法三：进一步改进
public int longestConsecutiveSequence(int[] nums)
// 定义一个变量，保存当前最长连续序列的长度
int maxLength = 0;
// 定义一个HashSet，保存所有出现的数值
HashSet<Integer> hashSet = new HashSet<>();
// 1. 遍历所有元素，保存到HashSet
for (int num: nums)
hashSet.add(num);
// 2. 遍历数组，以每个元素作为起始点，寻找连续序列
for (int i = 0; i < nums.length; i++)
// 保存当前元素作为起始点
int currNum = nums[i];
// 保存当前连续序列长度
int currLength = 1;
// 判断：只有当前元素的前驱不存在的情况下，才去进行寻找连续序列的操作
if (!hashSet.contains(currNum - 1))
// 寻找后续数字，组成连续序列
while ( hashSet.contains(currNum + 1) )
currLength ++;
currNum ++;
// 判断当前连续序列长度是否为最大
maxLength = currLength > maxLength ? currLength : maxLength;
return maxLength;
复杂度分析
时间复杂度：O(N)。外层循环需要 O(n) 的时间复杂度，只有当一个数是连续序列的第一个数的情况下才会进入内层循环，然后在内层循环中匹配连续序列中的数，因此数组中的每个数只会进入内层循环一次。
空间复杂度：O(N)。哈希表保存数组中所有数据需要O(N)的内存空间。
4.LRU缓存机制
4.1 题目说明
运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。
实现 LRUCache 类：
- LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
- int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
- void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。
进阶：你是否可以在 O(1) 时间复杂度内完成这两种操作？
示例：
输入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]
解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 1=1
lRUCache.put(2, 2); // 缓存是 1=1, 2=2
lRUCache.get(1); // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 1=1, 3=3
lRUCache.get(2); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 4=4, 3=3
lRUCache.get(1); // 返回 -1 (未找到)
lRUCache.get(3); // 返回 3
lRUCache.get(4); // 返回 4
提示：
- 1 <= capacity <= 3000
- 0 <= key <= 3000
- 0 <= value <= 104
- 最多调用 3 * 104 次 get 和 put
4.2 分析
LRU（Least recently used，最近最少使用）是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。
所谓的“最近最久未使用”，就是根据数据的历史访问记录来判断的，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。
LRU是最常见的缓存机制，在操作系统的虚拟内存管理中，有非常重要的应用，所以也是面试中的常客。
具体实现上，既然保存的是键值对，而且要根据key来判断数据是否在缓存中，那么就可以用一个HashMap来作为缓存的存储数据结构。这样，我们的访问和插入，就都可以以常数时间进行了。
需要额外考虑的是，缓存空间有限，所以这个HashMap要有一个容量限制；而且当达到容量上限时，我们会运用LRU的策略删除最近最少使用的那个数据。
这就要求我们必须把数据，按照一定的线性结构排列起来，最新访问的数据放在后面，新数据的插入可以“顶掉”最前面的不常访问的数据。这种数据结构其实可以用链表来实现。
所以，我们最终可以使用一个哈希表+双向链表的数据结构，来实现LRU缓存机制。
4.3 方法一：使用LinkedHashMap
在java语言中，其实java.util下已经给我们封装好了这样的一个数据结构，就是“链式哈希表”——LinkedHashMap。它本身继承了HashMap，而它的节点Entry除了继承自HashMap.Node，还定义了before和after两个指针，从而实现了双向链表。
package com.webcode.hashmap;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
public class LRUCacheWithLinkedHashMap extends LinkedHashMap<Integer,Integer>
// 定义缓存容量
private int capacity;
public LRUCacheWithLinkedHashMap(int capacity)
super(capacity, 0.75f, true);
this.capacity = capacity;
// 访问数据的get方法
public int get(int key)
if (super.get(key) == null) return -1;
return super.get(key);
// put方法
public void put(int key, int value)
super.put(key, value);
// 重写是否删除元素的方法
@Override
protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest)
return size() > capacity;
public static void main(String[] args)
LRUCacheWithLinkedHashMap lRUCache = new LRUCacheWithLinkedHashMap(2);
lRUCache.put(1, 1); // 缓存是 1=1
lRUCache.put(2, 2); // 缓存是 1=1, 2=2
System.out.println(lRUCache.get(1)); // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 1=1, 3=3
System.out.println(lRUCache.get(2)); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 4=4, 3=3
System.out.println(lRUCache.get(1)); // 返回 -1 (未找到)
System.out.println(lRUCache.get(3)); // 返回 3
System.out.println(lRUCache.get(4)); // 返回 4
4.4 方法二：自定义哈希表+双向链表
上面的实现虽然简单，但是有取巧的嫌疑，如果在真正的面试中给出这样的代码，很可能面试官是无法满意的。我们需要做的，还是自己实现一个简单的双向链表，而不是直接套用语言自带的封装数据结构
package com.webcode.hashmap;
import java.util.HashMap;
// 自定义实现HashMap+双向链表的缓存机制
public class LRUCache
// 定义双向链表的节点类
class Node
int key;
int value;
Node next;
Node prev; // 指向前一个节点的指针
public Node()
public Node(int key, int value)
this.key = key;
this.value = value;
// 定义哈希表
private HashMap<Integer, Node> hashMap = new HashMap<Integer, Node>();
// 定义属性
private int capacity;
private int size;
// 定义头尾指针
private Node head, tail;
public LRUCache(int capacity)
this.capacity = capacity;
this.size = 0;
// 用哑节点定义哨兵，方便统一处理
head = new Node();
tail = new Node();
head.next = tail;
tail.prev = head;
// get方法
public int get(int key)
// 从哈希表中查找key，如果不存在的话就返回-1
Node node = hashMap.get(key);
if (node == null) return -1;
// 如果存在，将当前节点移到链表末尾
moveToTail(node);
return node.value;
// put操作
public void put(int key, int value)
// 同样先在哈希表中查找key
Node node = hashMap.get(key);
// 如果key存在，修改value，并移到末尾
if (node != null)
node.value = value;
moveToTail(node);
// 如果不存在，需要创建新的节点，插入到末尾
else
Node newNode = new Node(key, value);
hashMap.put(key, newNode); // 保存进哈希表
addToTail(newNode); // 添加到双向链表的末尾
size ++; // 当前size增大
// 如果超出了容量限制，删除链表头节点
if (size > capacity)
Node head = removeHead();
hashMap.remove(head.key);
size --;
// 移动节点到链表末尾
private void moveToTail(Node node)
removeNode(node);
addToTail(node);
// 通用方法，删除链表中的某一个节点
private void removeNode(Node node)
// 跳过当前node
node.prev.next = node.next;
node.next.prev = node.prev;
// 在链表末尾增加一个节点
private void addToTail(Node node)
node.next = tail;
node.prev = tail.prev; // 以原先的末尾节点作为前一个节点
tail.prev.next = node;
tail.prev = node;
// 删除头节点
private Node removeHead()
Node realHead = head.next;
removeNode(realHead);
return realHead;
public static void main(String[] args)
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 1=1
lRUCache.put(2, 2); // 缓存是 1=1, 2=2
System.out.println(lRUCache.get(1)); // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 1=1, 3=3
System.out.println(lRUCache.get(2)); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 4=4, 3=3
System.out.println(lRUCache.get(1)); // 返回 -1 (未找到)
System.out.println(lRUCache.get(3)); // 返回 3
System.out.println(lRUCache.get(4)); // 返回 4
复杂度分析
时间复杂度：O(1)。因为使用了HashMap和双向链表，对于 put 和 get 操作都可以在 O(1)时间完成。
空间复杂度：O(capacity)，因为哈希表和双向链表最多存储capacity+1个元素（超出缓存容量时，大小为capacity+1）。
以上是关于算法和数据结构解析-7 : 哈希表相关问题的主要内容，如果未能解决你的问题，请参考以下文章