【LeetCode 热题 100】15. 三数之和——排序 + 双指针解法

整体思路

这段代码旨在解决经典的算法问题------"三数之和" (3Sum) 。其核心目标是：从一个给定的整数数组 nums 中，找出所有和为 0 的、不重复的三元组。

该代码采用 "排序 + 双指针" 的策略，这是一种高效解决此类问题的标准方法。其整体思路可以分解为以下几个步骤：

排序：首先，对整个输入数组 nums进行升序排序。这一步是整个算法的基石，它带来了两个巨大的好处：
- 可以通过移动指针来有序地增大或减小三个数的和。
- 可以非常方便地处理重复的三元组。
固定一个数，转化问题 ：代码使用一个 for 循环来遍历排序后的数组。在每次循环中，它"固定"一个数 nums[l] 作为三元组的第一个元素。这样，原问题就从"找三个数"简化为"在数组的剩余部分找两个数，使它们与 nums[l] 的和为 0"。
双指针查找 ：对于每个固定的 nums[l]，代码在其右侧的子数组 [l+1, n-1] 中使用双指针技术来寻找另外两个数。
- 一个指针 m 从子数组的左端（l+1）开始。
- 另一个指针 r 从子数组的右端（n-1）开始。
指针移动与判断 ：在 while (m < r) 循环中，计算三个数 nums[l], nums[m], nums[r] 的和 sum。
- 如果 sum == 0，则找到了一个有效的三元组，将其存入结果列表 ans。
- 如果 sum < 0，说明和太小。由于数组是排序的，需要增大和，因此将左指针 m 向右移动 (m++)。
- 如果 sum > 0，说明和太大。需要减小和，因此将右指针 r 向左移动 (r--)。
处理重复解：为了确保结果中没有重复的三元组，代码中包含了非常关键的去重逻辑：
- 外层去重 ：在固定 nums[l] 时，if (l > 0 && nums[l] == nums[l - 1]) 判断会跳过与前一个固定的数相同的元素，确保每个数字只作为一次"固定数"的起始。
- 内层去重 ：当找到一个解 sum == 0 后，会使用额外的 while 循环来移动 m 和 r 指针，跳过所有与刚使用过的 nums[m] 和 nums[r] 值相同的元素。

通过以上步骤，该算法能够系统性地、无遗漏、无重复地找出所有满足条件的三元组。

完整代码

java 复制代码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        // 创建一个列表，用于存储最终的结果三元组
        List<List<Integer>> ans = new ArrayList<>();
        
        // 对输入数组进行升序排序，这是双指针算法的前提
        Arrays.sort(nums);
        
        // 获取数组的长度
        int n = nums.length;
        
        // 外层循环，遍历数组以固定三元组的第一个数 nums[l]
        // l 的上界是 n - 2，因为至少需要给 m 和 r 留下两个位置
        for (int l = 0; l < n - 2; l++) {
            
            // 【外层去重】
            // 如果 l > 0 (不是第一个元素)，并且当前固定的数与前一个数相同，
            // 那么以当前数开头的所有组合都已被前一个数覆盖，因此跳过以避免重复。
            if (l > 0 && nums[l] == nums[l - 1]) {
                continue;
            }
            
            // 初始化双指针：
            // m 指针（中间数）从 l 的下一个位置开始
            int m = l + 1;
            // r 指针（最右数）从数组的末尾开始
            int r = n - 1;
            
            // 当中间指针在最右指针的左边时，持续查找
            while (m < r) {
                // 计算三个指针指向的数字之和
                int sum = nums[l] + nums[m] + nums[r];
                
                // 情况一：找到了一个和为 0 的三元组
                if (sum == 0) {
                    // 将这个有效的三元组添加到结果列表中
                    ans.add(Arrays.asList(nums[l], nums[m], nums[r]));
                    
                    // 移动指针以寻找下一个可能的解
                    m++;
                    r--;
                    
                    // 【内层去重 - m 指针】
                    // 为避免重复记录如 [-2, 1, 1] 这样的解（当数组中有多个1时），
                    // 向右移动 m 指针，跳过所有与刚处理过的 nums[m-1] 相同的元素。
                    while (m < r && nums[m] == nums[m - 1]) {
                        m++;
                    }
                    
                    // 【内层去重 - r 指针】
                    // 同样地，向左移动 r 指针，跳过所有与刚处理过的 nums[r+1] 相同的元素。
                    while (m < r && nums[r] == nums[r + 1]) {
                        r--;
                    }
                
                // 情况二：和小于 0，说明需要更大的数来凑成 0
                } else if (sum < 0) {
                    // 将中间指针 m 向右移动，以增大总和
                    m++;
                    
                // 情况三：和大于 0，说明需要更小的数来凑成 0
                } else { // sum > 0
                    // 将最右指针 r 向左移动，以减小总和
                    r--;
                }
            }
        }
        
        // 返回包含所有不重复三元组的结果列表
        return ans;
    }
}

时空复杂度

时间复杂度: O(N²)
- 排序：Arrays.sort(nums) 的时间复杂度为 O(N log N) ，其中 N 是数组 nums 的长度。
- 循环与双指针 ：代码的主体是一个嵌套循环结构。
  - 外层 for 循环从 l = 0 遍历到 n - 2，其复杂度为 O(N)。
  - 内层 while (m < r) 循环中，m 指针和 r 指针在每次外层循环中最多只会相向移动扫描一次子数组。因此，对于每个固定的 l，双指针部分的时间复杂度是 O(N)。
- 综合来看，循环部分的总时间复杂度是 O(N) * O(N) = O(N²)。
- 算法的总时间复杂度由排序和循环两部分组成，即 O(N log N) + O(N²)。由于 N² 的增长速度快于 N log N，因此最终的时间复杂度由 O(N²) 主导。
空间复杂度: O(log N)
- 结果列表 ans ：我们通常分析的是额外空间复杂度，即不包括存储最终结果所需的空间。如果算上结果，空间复杂度会根据符合条件的解的数量而变化。
- 排序：Java 中 Arrays.sort() 对基本数据类型的排序（如 int[]）是基于双轴快排实现的。它需要 O(log N) 的栈空间用于递归。在最坏情况下，快排可能退化到 O(N) 的空间复杂度，但这非常罕见。
- 其他变量 ：如 l, m, r, n, sum 等变量只占用了常数级别的空间，即 O(1)。
- 因此，该算法主要的额外空间开销来自于排序算法的递归栈，所以空间复杂度为 O(log N)。