LeetCode高频算法题解析：哈希表与双指针实战

1. 算法刷题实战指南：四道经典LeetCode题目精解

在程序员的技术成长道路上，算法能力始终是衡量基本功的重要标尺。今天我想分享四道高频出现的LeetCode题目解法与思考过程，这些题目覆盖了哈希表、双指针、数组处理等常见考点，都是面试中的"常客"。无论你是准备技术面试还是想系统提升算法思维，这些案例都能提供直接的参考价值。

2. 两数之和：哈希表的经典应用

2.1 问题描述与暴力解法

给定一个整数数组nums和一个目标值target，要求在数组中找出和为目标值的两个整数，并返回它们的下标。最简单的暴力解法是双重循环遍历所有可能的组合：

python复制def twoSum(nums, target):
    for i in range(len(nums)):
        for j in range(i+1, len(nums)):
            if nums[i] + nums[j] == target:
                return [i, j]

这种解法时间复杂度为O(n²)，在数据量较大时性能明显不足。面试中仅提出这种解法通常无法让面试官满意。

2.2 哈希表优化方案

更优的解法是利用哈希表（字典）存储已遍历元素的值和索引，将查找时间从O(n)降到O(1)：

python复制def twoSum(nums, target):
    hashmap = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in hashmap:
            return [hashmap[complement], i]
        hashmap[num] = i

这个算法的时间复杂度降为O(n)，空间复杂度为O(n)。在实际编码时需要注意：

• 先检查补数再存入当前数，避免重复使用同一元素
• Python中字典的in操作平均时间复杂度为O(1)
• 边界情况要考虑空数组和找不到解的情况

3. 字母异位词分组：哈希与字符串处理的结合

3.1 问题核心理解

字母异位词指字母相同但排列不同的单词，如"eat"、"tea"、"ate"。题目要求将一组字符串按异位词分组。关键在于找到统一的标识来表示一组异位词。

3.2 解决方案对比

3.2.1 排序键值法

最直观的方法是将每个字符串排序后作为字典的键：

python复制def groupAnagrams(strs):
    from collections import defaultdict
    ans = defaultdict(list)
    for s in strs:
        key = tuple(sorted(s))
        ans[key].append(s)
    return list(ans.values())

时间复杂度：O(n*klogk)，其中n是字符串数量，k是字符串最大长度

3.2.2 计数键值法

对于字符集较小的情况（如仅小写字母），可以用字符计数作为键：

python复制def groupAnagrams(strs):
    from collections import defaultdict
    ans = defaultdict(list)
    for s in strs:
        count = [0] * 26
        for c in s:
            count[ord(c) - ord('a')] += 1
        ans[tuple(count)].append(s)
    return list(ans.values())

时间复杂度：O(n*k)，在k较大时优于排序法

提示：面试中可以先提出排序法，再优化为计数法，展示思考过程

4. 最长连续序列：哈希表的巧妙运用

4.1 问题分析

给定未排序的整数数组，找出数字连续的最长序列长度。要求算法时间复杂度为O(n)。例如[100,4,200,1,3,2]的最长连续序列是[1,2,3,4]，长度为4。

4.2 最优解法实现

使用哈希集合存储所有数字，然后只从序列的起始点开始计算：

python复制def longestConsecutive(nums):
    num_set = set(nums)
    max_length = 0
    
    for num in num_set:
        if num - 1 not in num_set:  # 确保是序列起点
            current_num = num
            current_length = 1
            
            while current_num + 1 in num_set:
                current_num += 1
                current_length += 1
                
            max_length = max(max_length, current_length)
            
    return max_length

这个算法虽然看似有嵌套循环，但每个数字最多被访问两次（作为序列起点和中间节点），因此整体时间复杂度确实是O(n)。

5. 移动零：双指针的经典场景

5.1 问题要求

给定一个数组nums，将所有0移动到数组末尾，同时保持非零元素的相对顺序。必须在原数组上操作，不能拷贝额外的数组。

5.2 双指针解法详解

使用快慢指针可以高效完成这个任务：

python复制def moveZeroes(nums):
    slow = 0
    for fast in range(len(nums)):
        if nums[fast] != 0:
            nums[slow], nums[fast] = nums[fast], nums[slow]
            slow += 1

算法步骤解析：

1. slow指针指向下一个非零元素应该放置的位置
2. fast指针遍历整个数组
3. 当fast遇到非零元素时，与slow位置的元素交换
4. 交换后slow前进一位

时间复杂度O(n)，空间复杂度O(1)，完全符合题目要求。

5.3 变种与扩展

类似的双指针技巧还可以解决：

• 移除指定元素（LeetCode 27）
• 去重问题（LeetCode 26）
• 颜色分类问题（LeetCode 75）

6. 算法实战中的常见陷阱与优化技巧

6.1 边界条件处理

• 空数组输入
• 所有元素相同的情况
• 超大输入时的性能问题
• 元素全为零或全为非零的特殊情况

6.2 测试用例设计

针对每个问题，应该设计以下测试用例：

1. 常规情况
2. 空输入
3. 极值情况
4. 全部元素相同
5. 已经满足条件的情况

6.3 编码实现细节

• 变量命名要有意义（如slow/fast比i/j更清晰）
• 先写注释再写代码，理清思路
• 在IDE中逐步调试观察变量变化
• 编写简单的测试函数验证正确性

7. 从题目到算法思维的提升

这四道题目虽然表面不同，但核心都考察了数据结构的选择能力。在实际面试中，面试官更看重：

1. 从暴力解法到优化解法的思考过程
2. 时间/空间复杂度分析的准确性
3. 代码实现的简洁性和鲁棒性
4. 处理边界条件的意识

建议的刷题方法：

• 第一遍独立思考，尝试各种解法
• 第二遍学习最优解，理解其精髓
• 第三遍隔天重写，检验掌握程度
• 定期复习相似题目，建立知识关联

对于算法学习，我的个人经验是：与其追求刷题数量，不如深入理解每道题目背后的算法思想。真正掌握哈希表、双指针这些核心技巧后，面对新题目时就能更快找到解题方向。