LeetCode Hot 100 | 哈希表专题（C++ 题解）

原创已于 2026-04-02 19:50:37 修改 · 409 阅读

8 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#leetcode #散列表 #c++

于 2026-03-31 15:58:34 首次发布

LeetCode Hot 100 | 哈希表专题（C++ 题解）

哈希表是「空间换时间」的经典代表，通过 O(1) 的查找把许多 O(n²) 暴力问题降到 O(n)。本文涵盖 LeetCode Hot 100 中 3 道经典哈希表题目，配有图解和详细思路分析。

一、1. Two Sum（两数之和）🟢 简单

题目描述

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

2 <= nums.length <= 10^4
-10^9 <= nums[i] <= 10^9
-10^9 <= target <= 10^9
只会存在一个有效答案

解题思路

暴力思路： 双重循环枚举所有数对，O(n²)，n=10⁴ 时约 10⁸ 次操作，勉强过但不优雅。

哈希表优化：

问题等价于：遍历到 nums[i] 时，查「之前是否出现过值等于 target - nums[i] 的元素」。

用 unordered_map<值, 下标> 记录已遍历的元素。遍历到 nums[i]：

若 map 中存在 target - nums[i]：直接返回 {i, map[target - nums[i]]}
否则将 nums[i] → i 存入 map，继续遍历

举例 nums = [2, 7, 11, 15], target = 9：

i=0，nums[0]=2：查 9-2=7，map 中无，存入 {2:0}
i=1，nums[1]=7：查 9-7=2，map 中有 {2:0}，返回 {1, 0}

最终 [0,1]，正确！全程只遍历了 2 个元素。

为什么先查后存？ 防止 nums[i] + nums[i] == target 时错误地使用同一个元素两次。

复杂度： 时间 O(n)，空间 O(n)

C++ 代码

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> umap;

        for (int i = 0; i < nums.size(); i++) {
            if (umap.count(target - nums[i]))
                return {i, umap[target - nums[i]]};
            else
                umap[nums[i]] = i;
        }

        return {0, 0};
    }
};

二、49. Group Anagrams（字母异位词分组）🟡 中等

题目描述

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的所有字母得到的一个新单词。

示例 1：

输入: strs = ["eat","tea","tan","ate","nat","bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]

示例 2：

输入: strs = [""]
输出: [[""]]

示例 3：

输入: strs = ["a"]
输出: [["a"]]

提示：

1 <= strs.length <= 10^4
0 <= strs[i].length <= 100
strs[i] 仅包含小写字母

解题思路

核心问题： 如何判断两个字符串是字母异位词？最直观的方法是排序后比较——字母异位词排序后相同。以排序后的字符串作为 key，把原字符串归入对应的组。

排序方案： 对每个字符串排序得到 key，用 unordered_map<string, vector<string>> 分组。时间 O(n·k log k)，k 是字符串平均长度。

字符频率方案（更快）： 不排序，用长度为 26 的字符频率数组作为 key。两个字母异位词的频率数组完全相同。array<int, 26> 可直接作哈希表的 key（需要自定义哈希函数）。

自定义哈希：用 accumulate + 位运算把 26 个 int 折叠成一个 size_t，保证不同频率数组大概率得到不同哈希值。

举例 strs = ["eat", "tea", "tan", "ate", "nat", "bat"]：

字符串	频率数组（只列非零）	key
“eat”	{a:1,e:1,t:1}	[0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0]
“tea”	{a:1,e:1,t:1}	同上 → 同组
“tan”	{a:1,n:1,t:1}	不同
“ate”	{a:1,e:1,t:1}	同第一组
“nat”	{a:1,n:1,t:1}	同 “tan” → 同组
“bat”	{a:1,b:1,t:1}	独立

最终三组：[“eat”,“tea”,“ate”]、[“tan”,“nat”]、[“bat”]，正确！

复杂度： 时间 O(n·k)，空间 O(n·k)

C++ 代码

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        auto hashArray = [fn = hash<int>{}](const array<int, 26> &arr){
            return accumulate(arr.begin(), arr.end(), 0, [&](int acc, int num){
                return (acc << 1) ^ fn(num);
            });
        };

        unordered_map<array<int, 26>, vector<string>, decltype(hashArray)> umaps(0, hashArray);

        array<int, 26> arr;
        for (const auto str : strs) {
            arr = {0};
            for (const auto c : str) {
                arr[c - 'a']++;
            }

            umaps[arr].emplace_back(move(str));
        }

        vector<vector<string>> ans;
        for (auto map : umaps) {
            ans.emplace_back(map.second);
        }

        return ans;
    }
};

三、128. Longest Consecutive Sequence（最长连续序列）🟡 中等

题目描述

给定一个未排序的整数数组 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 <= 10^5
-10^9 <= nums[i] <= 10^9

解题思路

暴力思路： 排序后扫描，找最长连续段。O(n log n)，不满足题目 O(n) 要求。

哈希表 + 只从序列起点开始计数：

先将所有数存入 unordered_set，O(1) 查找。

然后遍历集合中每个数 num：

若 num - 1 在集合中：说明 num 不是某个连续序列的起点，跳过（这是关键剪枝！）
若 num - 1 不在集合中：num 是起点，从 num 开始向右扩展，统计序列长度

这个剪枝保证每个数最多被访问两次（一次作为枚举对象，一次作为某序列的扩展步骤），总时间 O(n)。

举例 nums = [100, 4, 200, 1, 3, 2]：

集合 = {1, 2, 3, 4, 100, 200}

遍历：

100：99 不在集合 → 起点，扩展 100→101（不在）= 长度 1
4：3 在集合 → 跳过
200：199 不在 → 起点，扩展 200→201（不在）= 长度 1
1：0 不在 → 起点，扩展 1,2,3,4→5（不在）= 长度 4 ✅
3：2 在 → 跳过
2：1 在 → 跳过

最长序列长度 = 4，正确！

复杂度： 时间 O(n)，空间 O(n)

C++ 代码

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        unordered_set<int> uset;
        int ans = 0;

        for (auto num : nums) {
            uset.insert(num);
        }

        for (auto num : uset) {
            if (!uset.count(num - 1)) {
                int val = num;
                int tmp_len = 1;
                while (uset.count(++val)) {
                    tmp_len++;
                }

                ans = max(ans, tmp_len);
            }
        }

        return ans;
    }
};

总结

题号	题目	难度	核心技巧	时间复杂度
1	两数之和	🟢 简单	哈希表查找补数	O(n)
49	字母异位词分组	🟡 中等	字符频率数组作 key	O(n·k)
128	最长连续序列	🟡 中等	哈希集合 + 只从起点扩展	O(n)

哈希表的本质： 用 O(n) 空间预处理数据，换取 O(1) 的查找，把「枚举所有可能」变成「直接验证答案是否存在」，从而把 O(n²) 降到 O(n)。

如果这篇文章对你有帮助，欢迎点赞收藏 ⭐，也欢迎在评论区交流！