哈希表在算法题中的实战应用与优化技巧

1. 哈希表在算法题中的实战应用

作为一名刷过上百道LeetCode题目的程序员，我深刻体会到哈希表在算法解题中的重要性。今天我想分享四个经典题目，通过它们来剖析哈希表的不同实现方式和使用技巧。

1.1 为什么选择这四个题目

这四个题目看似简单，却涵盖了哈希表的三种主要实现方式：数组、unordered_set和unordered_map。它们分别对应着不同的使用场景：

• 数组：适用于键范围明确且有限的情况
• unordered_set：需要快速查找且不关心顺序的场景
• unordered_map：需要建立键值对映射关系的情况

接下来，我将逐个分析这些题目，分享我的解题思路和优化过程。

2. 有效的字母异位词

2.1 题目解析与暴力解法

字母异位词是指由相同字母重新排列形成的单词。最直观的解法是对两个字符串排序后比较：

cpp复制bool isAnagram(string s, string t) {
    sort(s.begin(), s.end());
    sort(t.begin(), t.end());
    return s == t;
}

这种方法时间复杂度为O(nlogn)，空间复杂度O(1)。但我们可以用哈希表优化到O(n)。

2.2 哈希表优化方案

使用数组作为哈希表是最佳选择，因为：

1. 字母数量有限（26个小写字母）
2. 数组访问时间复杂度O(1)
3. 内存占用固定且小

cpp复制bool isAnagram(string s, string t) {
    if(s.size() != t.size()) return false;
    
    int record[26] = {0};
    for(char c : s) record[c - 'a']++;
    for(char c : t) {
        if(--record[c - 'a'] < 0) 
            return false;
    }
    return true;
}

2.3 关键点解析

1. c - 'a'：将字符转换为0-25的索引
2. 先检查长度：长度不同直接返回false
3. 提前终止：当计数为负时立即返回

注意：在C++中，字符本质是ASCII码，所以这种算术运算是安全的。但如果是Unicode字符，这种方法就不适用了。

3. 两个数组的交集

3.1 问题分析与暴力解法

最直接的思路是双层循环遍历两个数组：

cpp复制vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    vector<int> result;
    for(int num1 : nums1) {
        for(int num2 : nums2) {
            if(num1 == num2) {
                // 去重逻辑
                if(find(result.begin(), result.end(), num1) == result.end()) {
                    result.push_back(num1);
                }
            }
        }
    }
    return result;
}

这种方法时间复杂度O(n²)，效率很低。

3.2 使用unordered_set优化

unordered_set的查找时间复杂度为O(1)，非常适合这个场景：

cpp复制vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    unordered_set<int> result_set;
    unordered_set<int> nums_set(nums1.begin(), nums1.end());
    
    for(int num : nums2) {
        if(nums_set.find(num) != nums_set.end()) {
            result_set.insert(num);
        }
    }
    
    return vector<int>(result_set.begin(), result_set.end());
}

3.3 代码细节解析

1. nums_set(nums1.begin(), nums1.end())：直接通过迭代器构造set，自动去重
2. find()方法：返回迭代器，找不到时等于end()
3. 范围for循环：for(int num : nums2)是C++11特性，更简洁

实际项目中，如果数据量很大，可以考虑先对两个数组排序，然后用双指针法，空间复杂度可以降到O(1)

4. 快乐数

4.1 问题理解与数学分析

快乐数的定义看似简单，但隐藏着一个关键点：如果不是快乐数，计算过程会进入循环。这正是使用哈希表检测循环的理想场景。

4.2 解题思路与实现

cpp复制class Solution {
public:
    int getSum(int n) {
        int sum = 0;
        while(n > 0) {
            int digit = n % 10;
            sum += digit * digit;
            n /= 10;
        }
        return sum;
    }
    
    bool isHappy(int n) {
        unordered_set<int> seen;
        while(true) {
            int sum = getSum(n);
            if(sum == 1) return true;
            if(seen.count(sum)) return false;
            seen.insert(sum);
            n = sum;
        }
    }
};

4.3 关键技巧

1. 数字分解：n % 10获取最后一位，n /= 10去掉最后一位
2. 循环检测：用set记录已经出现过的数字
3. 提前终止：当sum为1或发现重复时立即返回

有趣的是，所有非快乐数最终都会进入4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4的循环

5. 两数之和

5.1 暴力解法分析

最直观的方法是双重循环：

cpp复制vector<int> twoSum(vector<int>& nums, int target) {
    for(int i = 0; i < nums.size(); i++) {
        for(int j = i + 1; j < nums.size(); j++) {
            if(nums[i] + nums[j] == target) {
                return {i, j};
            }
        }
    }
    return {};
}

时间复杂度O(n²)，显然不够高效。

5.2 哈希表优化方案

使用unordered_map存储已经遍历过的数字及其索引：

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.count(complement)) {
            return {num_map[complement], i};
        }
        num_map[nums[i]] = i;
    }
    return {};
}

5.3 实现细节

1. num_map.count(complement)：检查补数是否存在
2. 边遍历边存储：不需要预先处理整个数组
3. 一次遍历：时间复杂度优化到O(n)

注意：题目假设每种输入只有一个答案，所以找到后可以直接返回。如果有多个解，需要调整算法。

6. 哈希表选择指南

通过这四个题目，我们可以总结出哈希表实现的选择策略：

7. C++ STL使用技巧

7.1 unordered_set/map常用操作

cpp复制unordered_set<int> s;
s.insert(1);       // 插入元素
s.erase(1);        // 删除元素
s.count(1);        // 检查存在性
s.find(1) != s.end(); // 查找元素

unordered_map<int, string> m;
m[1] = "one";      // 插入或修改
m.insert({2, "two"}); // 插入
m.count(1);        // 检查键是否存在
m.find(1)->second; // 访问值

7.2 性能注意事项

1. 预分配空间：如果知道元素数量，可以用reserve()减少rehash
2. 自定义哈希函数：对于复杂对象可能需要提供哈希函数
3. 负载因子：影响哈希冲突概率，可通过max_load_factor()调整

8. 常见错误与调试技巧

8.1 典型错误案例

1. 忘记处理空输入
2. 数组越界（如字母题未检查大小写）
3. 哈希表未初始化直接访问
4. 迭代器失效（在遍历时修改容器）

8.2 调试建议

1. 打印中间结果：特别是在循环中
2. 使用断言检查前提条件
3. 编写测试用例覆盖边界情况
4. 使用调试器逐步跟踪

9. 扩展练习建议

为了巩固哈希表的使用，建议尝试以下LeetCode题目：

1. 三数之和（No.15）
2. 四数之和（No.18）
3. 同构字符串（No.205）
4. 单词规律（No.290）
5. 字母异位词分组（No.49）

在实际编码中，我发现哈希表经常与其他算法结合使用，如双指针法、滑动窗口等。掌握好哈希表能显著提升解题效率。