LeetCode高频算法题解析：两数之和与字母异位词分组

1. LeetCode高频算法题深度解析

最近在准备算法面试的同学一定会经常遇到这几道经典题目：两数之和、字母异位词分组、最长连续序列和移动零。作为LeetCode上出现频率最高的几道题，它们不仅考察基础数据结构的使用，更考验我们对问题本质的理解和优化能力。今天我就结合自己刷题和面试的经验，带大家深入剖析这四道题的解题思路和优化技巧。

2. 两数之和的三种解法对比

2.1 暴力解法与时间复杂度分析

最直观的解法当然是双重循环遍历所有可能的组合：

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]
    return []

这种解法的时间复杂度是O(n²)，在数据量较大时性能会很差。我在实际测试中发现，当数组长度超过10⁴时，运行时间会明显增加。

2.2 哈希表优化方案

更高效的解法是利用哈希表（字典）存储已经遍历过的元素：

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

这个版本的时间复杂度降到了O(n)，空间复杂度也是O(n)。在实际面试中，面试官通常会期待你给出这个优化方案。

提示：使用哈希表时要注意处理重复元素的情况，特别是当数组中有重复值但题目允许使用相同元素时。

2.3 排序+双指针的变体

如果题目允许修改原数组，还可以先排序再用双指针：

python复制def twoSum(nums, target):
    nums.sort()
    left, right = 0, len(nums)-1
    while left < right:
        current = nums[left] + nums[right]
        if current == target:
            return [left, right]
        elif current < target:
            left += 1
        else:
            right -= 1
    return []

这种方法时间复杂度是O(nlogn)，主要消耗在排序上。虽然不如哈希表解法高效，但也是值得掌握的技巧。

3. 字母异位词分组的多种实现

3.1 基于排序的解法

字母异位词是指字母相同但排列不同的单词，如"eat"和"tea"。最直接的解法是对每个单词排序后作为key：

python复制def groupAnagrams(strs):
    groups = {}
    for s in strs:
        key = ''.join(sorted(s))
        if key not in groups:
            groups[key] = []
        groups[key].append(s)
    return list(groups.values())

这种方法的时间复杂度是O(n*klogk)，其中n是单词数量，k是最长单词长度。

3.2 计数统计优化

当单词长度较大时，排序开销会很高。可以用字母计数作为key：

python复制def groupAnagrams(strs):
    groups = {}
    for s in strs:
        count = [0]*26
        for c in s:
            count[ord(c)-ord('a')] += 1
        key = tuple(count)
        if key not in groups:
            groups[key] = []
        groups[key].append(s)
    return list(groups.values())

这种方法时间复杂度是O(n*k)，在某些情况下会更高效。

3.3 质数乘积法的巧妙应用

更巧妙的解法是利用质数的乘积唯一性：

python复制def groupAnagrams(strs):
    primes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101]
    groups = {}
    for s in strs:
        key = 1
        for c in s:
            key *= primes[ord(c)-ord('a')]
        if key not in groups:
            groups[key] = []
        groups[key].append(s)
    return list(groups.values())

这种方法避免了排序和计数，但要注意乘积可能溢出，适合单词长度不大的情况。

4. 最长连续序列的高效解法

4.1 排序法的局限性

最直观的解法是先排序再找最长连续序列：

python复制def longestConsecutive(nums):
    if not nums:
        return 0
    nums.sort()
    max_len = current = 1
    for i in range(1, len(nums)):
        if nums[i] == nums[i-1]+1:
            current += 1
            max_len = max(max_len, current)
        elif nums[i] != nums[i-1]:
            current = 1
    return max_len

这种方法时间复杂度是O(nlogn)，不符合题目要求的O(n)时间复杂度。

4.2 哈希集合的O(n)解法

更高效的解法是利用集合：

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

这种方法平均时间复杂度是O(n)，因为每个元素最多被访问两次。

注意：关键技巧是只有当当前数字是序列起点时才进行计数，避免重复计算。

4.3 并查集的应用

虽然并查集解法在这题中不是最优的，但了解这种数据结构对解决其他连通性问题很有帮助：

python复制class UnionFind:
    def __init__(self, nums):
        self.parent = {num:num for num in nums}
        self.size = {num:1 for num in nums}
    
    def find(self, x):
        while self.parent[x] != x:
            self.parent[x] = self.parent[self.parent[x]]
            x = self.parent[x]
        return x
    
    def union(self, x, y):
        x_root = self.find(x)
        y_root = self.find(y)
        if x_root == y_root:
            return
        if self.size[x_root] < self.size[y_root]:
            x_root, y_root = y_root, x_root
        self.parent[y_root] = x_root
        self.size[x_root] += self.size[y_root]

def longestConsecutive(nums):
    if not nums:
        return 0
    uf = UnionFind(nums)
    for num in nums:
        if num+1 in uf.parent:
            uf.union(num, num+1)
    return max(uf.size.values())

并查集解法的时间复杂度接近O(n)，但实际常数因子较大。

5. 移动零问题的多种解法

5.1 双指针标准解法

最常用的解法是使用快慢指针：

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

这种方法时间复杂度是O(n)，空间复杂度是O(1)，是最优解。

5.2 计数补零法

另一种思路是先移除非零元素再补零：

python复制def moveZeroes(nums):
    pos = 0
    for num in nums:
        if num != 0:
            nums[pos] = num
            pos += 1
    while pos < len(nums):
        nums[pos] = 0
        pos += 1

这种方法代码更直观，但最后补零的循环在某些情况下可能增加操作次数。

5.3 稳定排序思路

虽然不推荐实际使用，但了解排序的思路也有帮助：

python复制def moveZeroes(nums):
    nums.sort(key=lambda x: x == 0)

这种方法简洁但时间复杂度是O(nlogn)，且会改变非零元素的相对顺序。

6. 常见问题与优化技巧

6.1 两数之和的边界情况

• 数组中可能有负数
• 可能存在多个解，但题目通常只需要返回一个
• 元素可能重复，但索引不同

6.2 字母异位词的特殊处理

• 空字符串的处理
• 大小写敏感问题（题目通常说明是否区分大小写）
• 非字母字符的处理

6.3 最长连续序列的优化点

• 大数据量时的内存使用
• 重复元素的处理
• 整数溢出问题（虽然Python不用担心）

6.4 移动零的注意事项

• 保持非零元素的原始顺序
• 尽量减少写操作次数
• 避免不必要的元素交换

在实际面试中，除了写出正确的代码，还需要：

1. 先明确问题要求和边界条件
2. 讨论时间和空间复杂度
3. 考虑可能的优化方向
4. 写出清晰易读的代码
5. 准备测试用例验证代码

我个人的经验是，对于这类高频题目，理解多种解法比死记硬背更重要。比如两数之和的哈希表解法，其实可以推广到三数之和、四数之和等问题。字母异位词的分组思想也可以应用于其他需要分类的问题。掌握这些核心思路，就能举一反三解决更多算法问题。