资料网站模板国家高新技术企业认定

整体思路

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

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

1. 排序：首先，对整个输入数组 nums进行升序排序。这一步是整个算法的基石，它带来了两个巨大的好处：

   • 可以通过移动指针来有序地增大或减小三个数的和。
   • 可以非常方便地处理重复的三元组。

2. 固定一个数，转化问题：代码使用一个 for 循环来遍历排序后的数组。在每次循环中，它“固定”一个数 nums[l] 作为三元组的第一个元素。这样，原问题就从“找三个数”简化为“在数组的剩余部分找两个数，使它们与 nums[l] 的和为 0”。

3. 双指针查找：对于每个固定的 nums[l]，代码在其右侧的子数组 [l+1, n-1] 中使用双指针技术来寻找另外两个数。

   • 一个指针 m 从子数组的左端（l+1）开始。
   • 另一个指针 r 从子数组的右端（n-1）开始。

4. 指针移动与判断：在 while (m < r) 循环中，计算三个数 nums[l], nums[m], nums[r] 的和 sum。

   • 如果 sum == 0，则找到了一个有效的三元组，将其存入结果列表 ans。
   • 如果 sum < 0，说明和太小。由于数组是排序的，需要增大和，因此将左指针 m 向右移动 (m++)。
   • 如果 sum > 0，说明和太大。需要减小和，因此将右指针 r 向左移动 (r--)。

5. 处理重复解：为了确保结果中没有重复的三元组，代码中包含了非常关键的去重逻辑：

   • 外层去重：在固定 nums[l] 时，if (l > 0 && nums[l] == nums[l - 1]) 判断会跳过与前一个固定的数相同的元素，确保每个数字只作为一次“固定数”的起始。
   • 内层去重：当找到一个解 sum == 0 后，会使用额外的 while 循环来移动 m 和 r 指针，跳过所有与刚使用过的 nums[m] 和 nums[r] 值相同的元素。

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

完整代码

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)。