C++哈希表应用：从基础到LeetCode实战-代码聚汇网

C++哈希表应用：从基础到LeetCode实战

乔一帆丶

1. 哈希表基础概念与核心特性

哈希表（Hash Table）是一种基于键值对（key-value）存储数据的高效数据结构。在C++标准库中，map和unordered_map是两种最常见的哈希表实现。我们先从最基础的map容器开始解析。

哈希表的核心思想是通过哈希函数将键（key）映射到存储位置（value），从而实现平均O(1)时间复杂度的数据访问。map底层通常采用红黑树实现，这保证了元素的有序性，而unordered_map则使用真正的哈希表实现，元素无序但访问速度更快。

注意：虽然map在技术上不是纯哈希表（因为使用树结构而非哈希桶），但在日常使用中我们仍习惯将其归为哈希表家族，因为对外表现出的键值对特性是一致的。

map的几个关键特性需要特别注意：

键的唯一性：每个键在map中只能出现一次
自动排序：元素会按键的升序自动排列（对于unordered_map则无此特性）
动态内存：map会根据元素数量动态调整内存占用

2. map容器的基本操作解析

2.1 声明与初始化

在C++中使用map需要包含头文件：

cpp复制#include <map>

声明一个存储int到int映射的map：

cpp复制map<int, int> m;  // 键类型为int，值类型为int

初始化map的几种常见方式：

cpp复制// 直接插入元素
m[1] = 100;
m[2] = 200;

// 使用insert函数
m.insert(make_pair(3, 300));

// C++11统一初始化
map<int, int> m2 = {
    {1, 100},
    {2, 200},
    {3, 300}
};

2.2 元素访问与修改

访问map元素有两种主要方式：

cpp复制// 使用[]运算符
int val = m[1];  // 如果键不存在会自动创建，值为默认值(0)

// 使用at()函数
int val = m.at(1);  // 键不存在会抛出out_of_range异常

修改元素值：

cpp复制m[1] = 150;  // 直接通过键修改值

2.3 遍历map

C++11提供了简洁的遍历语法：

cpp复制for(auto& pair : m) {
    cout << pair.first << ": " << pair.second << endl;
}

也可以使用迭代器：

cpp复制for(auto it = m.begin(); it != m.end(); ++it) {
    cout << it->first << ": " << it->second << endl;
}

3. LeetCode 349题实战解析

3.1 题目理解与解法思路

题目要求找出两个数组的交集，且结果中的每个元素必须是唯一的。这正是哈希表的典型应用场景 - 我们需要快速判断一个元素是否存在于另一个集合中。

基本解题思路：

使用哈希表记录第一个数组中出现的所有数字
遍历第二个数组，检查数字是否存在于哈希表中
如果存在且尚未加入结果集，则加入结果并标记

3.2 代码实现详解

让我们深入分析提供的解法代码：

cpp复制class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> v;  // 存储结果的向量
        map<int,int> m; // 使用map作为哈希表
        
        // 遍历第一个数组，记录每个数字出现的次数
        for(auto i : nums1){
            m[i]++;
        }
        
        // 遍历第二个数组，检查交集
        for(auto i : nums2){
            if(m[i] > 0){  // 如果数字在第一个数组中出现过
                v.push_back(i);  // 加入结果集
                m[i] = 0;  // 标记为已处理，避免重复添加
            }
        }
        return v;
    }
};

3.3 关键点解析

哈希表初始化：map<int,int> m声明了一个键值都为int的map。键是数组元素，值是该元素出现的次数。
第一次遍历：for(auto i:nums1){ m[i]++; }
- 这里利用了map的一个特性：当访问不存在的键时，会自动创建该键并将值初始化为0
- m[i]++相当于将每个数字的出现次数加1
第二次遍历：if(m[i]>0){...}
- 检查当前数字是否在第一个数组中出现过
- 如果出现过（值>0），则加入结果集并将值设为0，避免重复添加

3.4 复杂度分析

时间复杂度：O(n + m)，其中n和m分别是两个数组的长度
空间复杂度：O(min(n,m))，最坏情况下需要存储较小数组的所有元素

4. 优化与变种解法

4.1 使用unordered_map提升性能

由于我们不需要元素有序，可以使用unordered_map获得更好的平均时间复杂度：

cpp复制unordered_map<int,int> m;  // 替换map为unordered_map

unordered_map使用哈希表实现，插入和查找的平均时间复杂度为O(1)，而map使用红黑树实现，这些操作的时间复杂度为O(log n)。

4.2 使用set简化代码

由于题目只需要知道元素是否存在，不需要计数，可以使用set：

cpp复制vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    unordered_set<int> s(nums1.begin(), nums1.end());
    vector<int> res;
    
    for(int num : nums2){
        if(s.erase(num)){  // 如果元素存在set中，erase会返回1
            res.push_back(num);
        }
    }
    return res;
}

4.3 排序+双指针解法

如果不使用哈希表，还可以先排序然后使用双指针：

cpp复制vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    sort(nums1.begin(), nums1.end());
    sort(nums2.begin(), nums2.end());
    
    vector<int> res;
    int i = 0, j = 0;
    while(i < nums1.size() && j < nums2.size()){
        if(nums1[i] < nums2[j]){
            i++;
        }else if(nums1[i] > nums2[j]){
            j++;
        }else{
            // 避免重复添加
            if(res.empty() || res.back() != nums1[i]){
                res.push_back(nums1[i]);
            }
            i++;
            j++;
        }
    }
    return res;
}

5. 哈希表常见问题与调试技巧

5.1 常见错误排查

键不存在时的行为：
- 使用[]访问不存在的键会自动创建该键
- 使用at()访问不存在的键会抛出异常
- 在不确定键是否存在时，先用find()检查
迭代器失效：
- 在遍历过程中修改map可能导致迭代器失效
- 安全的做法是先收集需要修改的键，遍历完成后再修改
性能问题：
- 当数据量很大时，unordered_map通常比map快
- 但unordered_map在最坏情况下时间复杂度会退化到O(n)

5.2 调试技巧

打印map内容：

cpp复制for(const auto& pair : m){
    cout << "Key: " << pair.first << " Value: " << pair.second << endl;
}

检查元素是否存在：

cpp复制if(m.find(key) != m.end()){
    // 键存在
}

统计各种操作耗时：

cpp复制#include <chrono>

auto start = chrono::high_resolution_clock::now();
// 要测试的代码
auto end = chrono::high_resolution_clock::now();
auto duration = chrono::duration_cast<chrono::microseconds>(end - start);
cout << "耗时: " << duration.count() << "微秒" << endl;

6. 哈希表在算法竞赛中的应用场景

哈希表在算法问题中有着广泛的应用，以下是一些典型场景：

频率统计：统计元素出现次数，如本题
快速查找：判断元素是否存在，时间复杂度O(1)
缓存实现：实现LRU缓存等数据结构
去重处理：快速去除重复元素
两数之和：通过哈希表存储补数，快速查找

6.1 实际案例：两数之和问题

LeetCode第1题"两数之和"是哈希表的经典应用：

cpp复制vector<int> twoSum(vector<int>& nums, int target) {
    unordered_map<int, int> num_map;
    for(int i = 0; i < nums.size(); i++){
        int complement = target - nums[i];
        if(num_map.find(complement) != num_map.end()){
            return {num_map[complement], i};
        }
        num_map[nums[i]] = i;
    }
    return {};
}

这个解法通过一次遍历即可解决问题，时间复杂度O(n)，空间复杂度O(n)。

6.2 实际案例：字母异位词分组

LeetCode第49题"字母异位词分组"：

cpp复制vector<vector<string>> groupAnagrams(vector<string>& strs) {
    unordered_map<string, vector<string>> groups;
    for(const string& s : strs){
        string key = s;
        sort(key.begin(), key.end());
        groups[key].push_back(s);
    }
    
    vector<vector<string>> result;
    for(auto& pair : groups){
        result.push_back(pair.second);
    }
    return result;
}

这里使用排序后的字符串作为哈希表的键，将字母异位词分组存储。