如何用Python解决LeetCode第15题三数之和问题？
- 内容介绍
- 文章标签
- 相关推荐
本文共计1366个文字，预计阅读时间需要6分钟。
题目：给定一个包含n个整数的数组nums，判断nums中是否存在三个元素a、b、c，使得a+b+c=0。请找出所有和为0且不重复的三元组。
内容：编写一个函数，输入一个数组nums，输出所有和为0的不重复三元组。注意：答案中不能包含重复的三元组。
题目给你一个包含 n 个整数的数组nums，判断nums中是否存在三个元素 a，b，c ，使得a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例 1：
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
示例 2：
输入：nums = []
输出：[]
示例 3：
输入：nums = [0]
输出：[]
三数之和的暴力解法是写一个三重循环，这样的时间复杂度是O(n^3)。
但是可以通过双指针法，将两重循环变成一重循环，这样的话时间复杂度就会变成O(n^2)。然后再进一步通过各种剪枝的操作，进一步加快计算速度。
因为使用到了双指针法，所以必然要先对数组进行排序，这样才能通过比较大小来判断该移动哪个指针。
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
// 先排序，Arrays.sort()的时间复杂度O(n*log(n))
Arrays.sort(nums);
for (int i = 0; i < nums.length - 2; i++) {
// left在i+1的位置，right在末尾的位置，不断向中间搜索
// 这也是i的循环，为什么结束条件是 i < nums.length - 2 的原因
int left = i + 1;
int right = nums.length - 1;
while (left < right) {
int sum = nums[left] + nums[right] + nums[i];
if (sum == 0) {
// Case1. 三个数的和为0，则找到了我们想要的三个数
ArrayList<Integer> list = new ArrayList<>();
list.add(nums[i]);
list.add(nums[left]);
list.add(nums[right]);
result.add(list);
left++;
right--;
} else if (sum < 0) {
// Case2. 三个数的和小于0，则说明这三个数太小了，则把左边的指针往右边挪一下
left++;
} else {
// Case3. 三个数的和大于0，则说明这三个数太大了，则把右边的指针往左边挪一下
right--;
}
}
}
return result;
}
如上，其实就实现了一个for循环+双指针搜索的思想。
但是这其实是有问题的。问题就在于题干说的答案中不可以包含重复的三元组。
- Case1.
[-2, -1, -1, 0, 1]，用如上代码搜索，会得到两个重复的答案[-1, 0, 1]、[-1, 0, 1]。 - Case2.
[-2, -1, 0, 1, 1]，用如上代码搜索，会得到两个重复的答案[-1, 0, 1]、[-1, 0, 1]。
原因就在于：
i的值可能会重复（如Case1）；left或right的值可能会重复（如Case2）
所以接下来我们需要去进行去重。
去重可以有三种方法：
- 在循环前，先把nums去重。如，把nums放进set；
- 把包含结果的list放进result之前，先判断一下result是否contains这个list；
- 在循环的时候加入一些去重的操作
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(nums);
for (int i = 0; i < nums.length - 2; i++) {
// 1. 对i去重
if (i != 0 && nums[i - 1] == nums[i]) {
continue;
}
int left = i + 1;
int right = nums.length - 1;
while (left < right) {
int sum = nums[left] + nums[right] + nums[i];
if (sum == 0) {
ArrayList<Integer> list = new ArrayList<>();
list.add(nums[i]);
list.add(nums[left]);
list.add(nums[right]);
result.add(list);
// 2. 对left的值去重
while (left < right && nums[left] == nums[left + 1]) {
left++;
}
// 2. 对right的值去重
while (left < right && nums[right] == nums[right - 1]) {
right--;
}
left++;
right--;
} else if (sum < 0) {
left++;
} else {
right--;
}
}
}
return result;
}
好，到现在，这个代码已经是一个能够解决三数相加问题的一个代码了。程序用时：
那么我们再尝试优化剪枝，加快一下计算的速度。
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
// 1. 如果nums的length小于3，则不可能会有和为0的三个元素，直接return
if (nums.length < 3) {
return result;
}
Arrays.sort(nums);
// 2. 如果排序之后，最小的三个元素和大于0，则不可能会有和为0的三个元素，直接return
if (nums[0] + nums[1] + nums[2] > 0) {
return result;
}
for (int i = 0; i < nums.length - 2; i++) {
if (i != 0 && nums[i - 1] == nums[i]) {
continue;
}
// 3. 如果i和之后的两个最小的元素的和大于0，则i及i之后的元素都找不到和为0的三个元素，直接break循环
if (nums[i] + nums[i + 1] + nums[i + 2] > 0) {
break;
}
int left = i + 1;
int right = nums.length - 1;
while (left < right) {
int sum = nums[left] + nums[right] + nums[i];
if (sum == 0) {
ArrayList<Integer> list = new ArrayList<>();
list.add(nums[i]);
list.add(nums[left]);
list.add(nums[right]);
result.add(list);
// 2. 对left的值去重
while (left < right && nums[left] == nums[left + 1]) {
left++;
}
// 2. 对right的值去重
while (left < right && nums[right] == nums[right - 1]) {
right--;
}
left++;
right--;
} else if (sum < 0) {
left++;
} else {
right--;
}
}
}
return result;
}
这样，就完成了一个三数之和的题目。程序用时：
本文共计1366个文字，预计阅读时间需要6分钟。
题目：给定一个包含n个整数的数组nums，判断nums中是否存在三个元素a、b、c，使得a+b+c=0。请找出所有和为0且不重复的三元组。
内容：编写一个函数，输入一个数组nums，输出所有和为0的不重复三元组。注意：答案中不能包含重复的三元组。
题目给你一个包含 n 个整数的数组nums，判断nums中是否存在三个元素 a，b，c ，使得a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例 1：
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
示例 2：
输入：nums = []
输出：[]
示例 3：
输入：nums = [0]
输出：[]
三数之和的暴力解法是写一个三重循环，这样的时间复杂度是O(n^3)。
但是可以通过双指针法，将两重循环变成一重循环，这样的话时间复杂度就会变成O(n^2)。然后再进一步通过各种剪枝的操作，进一步加快计算速度。
因为使用到了双指针法，所以必然要先对数组进行排序，这样才能通过比较大小来判断该移动哪个指针。
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
// 先排序，Arrays.sort()的时间复杂度O(n*log(n))
Arrays.sort(nums);
for (int i = 0; i < nums.length - 2; i++) {
// left在i+1的位置，right在末尾的位置，不断向中间搜索
// 这也是i的循环，为什么结束条件是 i < nums.length - 2 的原因
int left = i + 1;
int right = nums.length - 1;
while (left < right) {
int sum = nums[left] + nums[right] + nums[i];
if (sum == 0) {
// Case1. 三个数的和为0，则找到了我们想要的三个数
ArrayList<Integer> list = new ArrayList<>();
list.add(nums[i]);
list.add(nums[left]);
list.add(nums[right]);
result.add(list);
left++;
right--;
} else if (sum < 0) {
// Case2. 三个数的和小于0，则说明这三个数太小了，则把左边的指针往右边挪一下
left++;
} else {
// Case3. 三个数的和大于0，则说明这三个数太大了，则把右边的指针往左边挪一下
right--;
}
}
}
return result;
}
如上，其实就实现了一个for循环+双指针搜索的思想。
但是这其实是有问题的。问题就在于题干说的答案中不可以包含重复的三元组。
- Case1.
[-2, -1, -1, 0, 1]，用如上代码搜索，会得到两个重复的答案[-1, 0, 1]、[-1, 0, 1]。 - Case2.
[-2, -1, 0, 1, 1]，用如上代码搜索，会得到两个重复的答案[-1, 0, 1]、[-1, 0, 1]。
原因就在于：
i的值可能会重复（如Case1）；left或right的值可能会重复（如Case2）
所以接下来我们需要去进行去重。
去重可以有三种方法：
- 在循环前，先把nums去重。如，把nums放进set；
- 把包含结果的list放进result之前，先判断一下result是否contains这个list；
- 在循环的时候加入一些去重的操作
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(nums);
for (int i = 0; i < nums.length - 2; i++) {
// 1. 对i去重
if (i != 0 && nums[i - 1] == nums[i]) {
continue;
}
int left = i + 1;
int right = nums.length - 1;
while (left < right) {
int sum = nums[left] + nums[right] + nums[i];
if (sum == 0) {
ArrayList<Integer> list = new ArrayList<>();
list.add(nums[i]);
list.add(nums[left]);
list.add(nums[right]);
result.add(list);
// 2. 对left的值去重
while (left < right && nums[left] == nums[left + 1]) {
left++;
}
// 2. 对right的值去重
while (left < right && nums[right] == nums[right - 1]) {
right--;
}
left++;
right--;
} else if (sum < 0) {
left++;
} else {
right--;
}
}
}
return result;
}
好，到现在，这个代码已经是一个能够解决三数相加问题的一个代码了。程序用时：
那么我们再尝试优化剪枝，加快一下计算的速度。
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
// 1. 如果nums的length小于3，则不可能会有和为0的三个元素，直接return
if (nums.length < 3) {
return result;
}
Arrays.sort(nums);
// 2. 如果排序之后，最小的三个元素和大于0，则不可能会有和为0的三个元素，直接return
if (nums[0] + nums[1] + nums[2] > 0) {
return result;
}
for (int i = 0; i < nums.length - 2; i++) {
if (i != 0 && nums[i - 1] == nums[i]) {
continue;
}
// 3. 如果i和之后的两个最小的元素的和大于0，则i及i之后的元素都找不到和为0的三个元素，直接break循环
if (nums[i] + nums[i + 1] + nums[i + 2] > 0) {
break;
}
int left = i + 1;
int right = nums.length - 1;
while (left < right) {
int sum = nums[left] + nums[right] + nums[i];
if (sum == 0) {
ArrayList<Integer> list = new ArrayList<>();
list.add(nums[i]);
list.add(nums[left]);
list.add(nums[right]);
result.add(list);
// 2. 对left的值去重
while (left < right && nums[left] == nums[left + 1]) {
left++;
}
// 2. 对right的值去重
while (left < right && nums[right] == nums[right - 1]) {
right--;
}
left++;
right--;
} else if (sum < 0) {
left++;
} else {
right--;
}
}
}
return result;
}
这样，就完成了一个三数之和的题目。程序用时：