当前位置：首页 > news >正文

【LeetCode 题解】算法：15.三数之和

news 来源：原创 2025/7/27 13:10:13

一、问题描述

在 LeetCode 上有这样一道经典的算法题，题目要求给定一个整数数组 nums，找出所有不重复的三元组 [nums[i], nums[j], nums[k]]，需要满足以下两个条件：

三个元素的索引互不相同，即 i != j，i != k，j != k。
这三个元素的和为 0，也就是 nums[i] + nums[j] + nums[k] == 0。

示例展示

示例 1：
- 输入：nums = [-1, 0, 1, 2, -1, -4]
- 输出：[[-1, -1, 2], [-1, 0, 1]]
- 解释：
  - nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0。
  - nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0。
  - 不同的三元组是 [-1, 0, 1] 和 [-1, -1, 2]，而且输出的顺序和三元组内元素的顺序并不重要。
示例 2：
- 输入：nums = [0, 1, 1]
- 输出：[]
- 解释：所有可能的三元组的和都不为 0。
示例 3：
- 输入：nums = [0, 0, 0]
- 输出：[[0, 0, 0]]
- 解释：唯一可能的三元组的和为 0。

二、思路分析

暴力法（不可取）

暴力法的思路是尝试数组中所有可能的三元组组合。对于一个长度为 n 的数组，需要三层嵌套循环来遍历所有组合，其时间复杂度为 O(n3)。当数组规模较大时，这种方法的效率极低，会导致程序运行时间过长，因此在实际应用中不可行。

哈希表法（有优化空间但较复杂）

此方法的思路是先遍历数组中的每个元素 nums[i]，将问题转化为在剩余元素中寻找两数之和为 -nums[i] 的问题。可以使用哈希表来记录元素及其出现的位置，这样在查找互补元素时可以将时间复杂度从 O(n) 降低到 O(1)。整体时间复杂度为 O(n2)。不过，使用哈希表法需要处理重复元素的问题，实现起来相对复杂。

排序 + 双指针法（最优解）

这是解决该问题的最优方案，步骤如下：

排序数组：对数组进行排序，排序后相同的元素会相邻排列，这便于后续跳过重复元素，减少不必要的计算。
固定第一个数：依次选取数组中的每个元素作为三元组的第一个数。
双指针查找：在剩余的元素中使用双指针，一个指针从第一个数的下一个元素开始向右移动，另一个指针从数组的最后一个元素开始向左移动，通过移动指针来寻找满足和为 0 的另外两个数。
时间复杂度：排序的时间复杂度为 O(nlogn)，双指针查找的时间复杂度为 O(n2)，因此总的时间复杂度为 O(n2)，该方法适合处理较大规模的数据。

三、详细解题代码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;public class ThreeSum {public static List<List<Integer>> threeSum(int[] nums) {// 用于存储最终结果的列表List<List<Integer>> result = new ArrayList<>();// 首先检查数组长度，如果小于 3，直接返回空列表if (nums == null || nums.length < 3) {return result;}// 对数组进行排序，方便后续去重和双指针操作Arrays.sort(nums);int n = nums.length;// 遍历数组，固定第一个数for (int i = 0; i < n; i++) {// 如果当前数大于 0，由于数组已排序，后面的数都大于 0，不可能找到和为 0 的三元组，直接跳出循环if (nums[i] > 0) {break;}// 跳过重复的第一个数if (i > 0 && nums[i] == nums[i - 1]) {continue;}// 初始化双指针，j 指向 i 的下一个元素，k 指向数组末尾int j = i + 1;int k = n - 1;// 双指针查找满足条件的另外两个数while (j < k) {int total = nums[i] + nums[j] + nums[k];if (total == 0) {// 找到满足条件的三元组，添加到结果列表中result.add(Arrays.asList(nums[i], nums[j], nums[k]));// 跳过重复的第二个数while (j < k && nums[j] == nums[j + 1]) {j++;}// 跳过重复的第三个数while (j < k && nums[k] == nums[k - 1]) {k--;}// 移动指针继续寻找j++;k--;} else if (total < 0) {// 总和小于 0，说明需要增大和，将左指针右移j++;} else {// 总和大于 0，说明需要减小和，将右指针左移k--;}}}return result;}public static void main(String[] args) {int[] nums = {-1, 0, 1, 2, -1, -4};List<List<Integer>> result = threeSum(nums);for (List<Integer> triplet : result) {System.out.println(triplet);}}
}

代码解释

1、输入检查：首先检查数组是否为空或者长度是否小于 3，如果是则直接返回空列表。

2、数组排序：使用 Arrays.sort(nums) 对数组进行排序，为后续的双指针操作和去重做准备。

3、遍历第一个数：使用 for 循环遍历数组，固定第一个数 nums[i]。如果 nums[i] 大于 0，由于数组已排序，后面的数都大于 0，不可能找到和为 0 的三元组，直接跳出循环。同时，跳过重复的第一个数。

4、双指针查找：初始化双指针 j 和 k，分别指向 i 的下一个元素和数组末尾。计算三个数的和 total，根据 total 的值进行不同的操作：

如果 total 等于 0，说明找到了一个满足条件的三元组，将其添加到结果列表中，并跳过重复的第二个数和第三个数，然后移动指针继续寻找。
如果 total 小于 0，说明需要增大和，将左指针 j 右移。
如果 total 大于 0，说明需要减小和，将右指针 k 左移。

5、返回结果：遍历结束后，返回存储结果的列表。

四、复杂度分析

时间复杂度：排序操作的时间复杂度为 O(nlogn)，双指针查找的时间复杂度为 O(n2)，因此总的时间复杂度为 O(n2)。
空间复杂度：排序所需的栈空间为 O(logn)，因此空间复杂度为 O(logn)。

五、常见问题解答

1. 为什么排序后可以去重？

排序后相同的元素会相邻排列，通过比较相邻元素是否相等，可以很方便地判断是否为重复元素。例如，在遍历第一个数时，如果当前数和前一个数相同，就跳过当前数，避免重复计算。

2. 如何处理全零数组？

当数组为 [0, 0, 0] 时，排序后第一个数为 0，双指针 j = 1 和 k = 2，计算 nums[i] + nums[j] + nums[k] 的和为 0，满足条件，将 [0, 0, 0] 添加到结果集中。

3. 能否用哈希表优化？

可以使用哈希表来优化，但需要处理大量的边界条件，例如重复元素的处理、元素自身为零的情况等。使用哈希表实现的代码复杂度较高，不如排序 + 双指针法简洁高效。

六、总结

核心思想：先对数组进行排序，然后通过双指针法在剩余元素中寻找满足条件的三元组，同时利用排序后相邻元素相同的特性进行去重。
关键点：正确处理指针的移动和重复元素的跳过逻辑，确保结果集中不包含重复的三元组。
适用场景：该算法适用于需要高效处理大规模数据，并且要求结果唯一的场景。

感谢各位的阅读，后续将持续给大家讲解力扣中的算法题，如果觉得这篇内容对你有帮助，别忘了点赞和关注，后续还有更多精彩的算法解析与你分享！