哈希表实战：5道LeetCode题解析与应用技巧

1. 哈希表基础与实战应用解析

哈希表（Hash Table）作为数据结构中的瑞士军刀，在算法面试和实际工程中都有着举足轻重的地位。今天我将通过LeetCode上5个经典题目，带大家深入理解哈希表的核心思想与应用技巧。不同于教科书式的讲解，我会结合自己刷题300+的经验，分享那些只有实战中才能获得的"肌肉记忆"。

哈希表本质上是通过哈希函数将键(key)映射到存储位置的数据结构，其平均时间复杂度可以达到O(1)。但实际应用中，我们需要考虑哈希冲突、负载因子、扩容机制等工程细节。在算法题中，我们更多关注其快速查找和去重的特性。下面这组题目由浅入深，覆盖了哈希表最典型的应用场景。

2. 字符统计类问题

2.1 有效的字母异位词（242题）

字母异位词(Anagram)是指由相同字母重新排列形成的不同单词。判断两个字符串是否为字母异位词，本质上就是检查它们的字符组成是否完全相同。

cpp复制class Solution {
public:
    bool isAnagram(string s, string t) {
        int arr[26]={0};
        for(char c : s) arr[c-'a']++;
        for(char c : t) arr[c-'a']--;
        for(int count : arr)
            if(count != 0) return false;
        return true;
    }
};

关键点解析：

1. 使用长度26的数组模拟哈希表，对应26个小写字母
2. s[i]-'a'将字符转换为0-25的索引（ASCII码相减）
3. 先增后减的计数策略，最终检查归零

注意：这种解法假设输入只有小写字母。如果包含Unicode字符，需要使用真正的哈希表（如unordered_map）

2.2 赎金信问题（383题）

这道题是字母异位词的变种，判断magazine中的字符能否组成ransomNote，区别在于字符数量要求"大于等于"而非"等于"。

cpp复制class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int arr[26]={0};
        for(char c : magazine) arr[c-'a']++;
        for(char c : ransomNote) 
            if(--arr[c-'a'] < 0) return false;
        return true;
    }
};

优化技巧：

1. 先统计magazine可以避免额外循环检查
2. 在遍历ransomNote时即时检查，提前返回false
3. 使用数组而非哈希表，效率更高（固定空间）

3. 集合操作问题

3.1 两个数组的交集（349题）

求两个数组的交集，结果需要去重。这里展示了两种截然不同的解法，体现了数据结构选择对算法的影响。

数组解法：

cpp复制class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        bool arr[1001]={false};
        for(int num : nums1) arr[num] = true;
        
        vector<int> res;
        for(int num : nums2)
            if(arr[num]) {
                res.push_back(num);
                arr[num] = false; // 避免重复添加
            }
        return res;
    }
};

集合解法：

cpp复制class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> set1(nums1.begin(), nums1.end());
        unordered_set<int> res;
        for(int num : nums2)
            if(set1.count(num)) res.insert(num);
        return vector<int>(res.begin(), res.end());
    }
};

性能对比：

经验：当数据范围已知且有限时（如本题0-1000），数组解法往往更高效。其他情况优先选择集合。

4. 循环检测问题

4.1 快乐数（202题）

快乐数的判定需要检测计算过程中是否出现循环，这正是哈希表的拿手好戏。

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

关键细节：

1. 分离数字各位求和的逻辑到单独函数
2. 使用unordered_set记录已经出现过的数字
3. 循环终止条件：n变为1或检测到重复

数学优化：
实际上所有不快乐的数最终都会进入4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4的循环。可以利用这个性质进一步优化。

5. 索引映射问题

5.1 两数之和（1题）

这道经典题目完美展示了哈希表如何将O(n²)的暴力解法优化为O(n)的优雅解法。

暴力解法：

cpp复制class Solution {
public:
    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 {};
    }
};

哈希表优化：

cpp复制class Solution {
public:
    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 {};
    }
};

为什么使用哈希表：

1. 查找补数(complement)的时间从O(n)降为O(1)
2. 边遍历边构建哈希表，只需一次遍历
3. 存储数值到索引的映射关系

常见错误：

• 先构建完整哈希表再查找，无法处理重复元素
• 忽略了元素不能重复使用的条件
• 返回值的顺序错误（应该先出现的索引在前）

6. 哈希表实战经验总结

经过这5道题目的锤炼，我总结出哈希表应用的几个关键判断点：

1. 当需要快速判断元素是否存在时：如快乐数的循环检测、两数之和的补数查找
2. 当需要统计元素出现频率时：如字母异位词、赎金信问题
3. 当需要去重操作时：如数组交集问题

进阶技巧：

• 固定范围的计数优先使用数组而非哈希表
• C++中unordered_set/map的insert和emplace区别
• 注意哈希表扩容的性能影响（预留空间）
• 自定义哈希函数的方法（对于复杂对象）

在实际面试中，当问题涉及上述场景时，可以优先考虑哈希表解法。记住，优秀的算法工程师不仅要知道怎么做，更要清楚为什么这样做以及各种解法的权衡取舍。