题目及测试
package pid015;
/*三数之和
给定一个包含 n 个整数的数组 nums,判断 nums 中是否存在三个元素 a,b,c ,使得 a + b + c = 0 ?找出所有满足条件且不重复的三元组。
注意:答案中不可以包含重复的三元组。
例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4],
满足要求的三元组集合为:
[
[-1, 0, 1],
[-1, -1, 2]
]
*/
import java.util.List;
public class main {
public static void main(String[] args) {
int [][] testTable = {{-1, 0, 1, 2, -1, -4},{0,1,2,-3,-1}};
for (int[] ito : testTable) {
test(ito);
}
}
private static void test(int[] ito) {
Solution solution = new Solution();
List<List<Integer>> rtn;
long begin = System.currentTimeMillis();
for(int i=0;i<ito.length;i++){
System.out.print(ito[i]+" ");
}
System.out.println();
//开始时打印数组
rtn= solution.threeSum(ito);//执行程序
long end = System.currentTimeMillis();
System.out.println("rtn=" );
for(int i=0;i<rtn.size();i++){
for(int j=0;j<rtn.get(i).size();j++){
System.out.print(rtn.get(i).get(j)+" ");
}
System.out.println();
}
System.out.println();
System.out.println("耗时:" + (end - begin) + "ms");
System.out.println("-------------------");
}
}
解法1(成功,184ms,很慢)
设置set,将所有的数字都放入set。
然后将数组排序。
先计算,两个负数,一个正数的情况,双指针计算完所有的负数的情况,根据set是否有对应正数来确定是否组合存在。
再计算两个正数,一个负数的情况。这时,注意三个0的情况
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result=new ArrayList<>();
List<Integer> now=new ArrayList<>();
//set中存放所有的数字
Set<Integer> set=new HashSet<>();
//将数字插入set
for(int i=0;i<nums.length;i++){
set.add(nums[i]);
}
//给数组排序
Arrays.sort(nums);
//数组长度
int length=nums.length;
//第一个>=0的数字的下标
int mid=length-1;
for(int i=0;i<length;i++){
if(nums[i]>=0){
mid=i;
break;
}
}
//先确定两个负数,一个正数的情况
int i=0;
int j=1;
while(i<mid){
while(j<mid){
if(set.contains(-nums[i]-nums[j])){
//如果存在的情况
now.add(nums[i]);
now.add(nums[j]);
now.add(-nums[i]-nums[j]);
result.add(now);
now=new ArrayList<>();
}
while(j+1<mid&&nums[j]==nums[j+1]){
//将j移到下一个不一样的数
j++;
}
j++;
}
while(i+1<mid&&nums[i]==nums[i+1]){
//将i移到下一个不一样的数
i++;
}
i++;
//重置j
j=i+1;
}
//再确定两个正数,一个负数数的情况
i=mid;
j=mid+1;
while(i<length){
while(j<length){
if(set.contains(-nums[i]-nums[j])){
//如果存在的情况
now.add(nums[i]);
now.add(nums[j]);
now.add(-nums[i]-nums[j]);
//存在2个0被认为是3个0的情况,检查
if(-nums[i]-nums[j]==0){
int zeros=0;
for(int k=mid;k<length;k++){
if(nums[k]==0){
zeros++;
}
else{
break;
}
}
if(zeros>=3){
//有3个0,加入,否则now情况
result.add(now);
now=new ArrayList<>();
}
else {
now=new ArrayList<>();
}
}else{
//普通情况
result.add(now);
now=new ArrayList<>();
}
}
while(j+1<length&&nums[j]==nums[j+1]){
//将j移到下一个不一样的数
j++;
}
j++;
}
while(i+1<length&&nums[i]==nums[i+1]){
//将i移到下一个不一样的数
i++;
}
i++;
//重置j
j=i+1;
}
return result;
}
解法2(别人的)
标准解法!!!
首先对数组进行排序,排序后固定一个数 nums[i],再使用左右指针指向 nums[i]后面的两端,数字分别为 nums[L]和 nums[R],计算三个数的和 sum判断是否满足为 0,满足则添加进结果集
如果 nums[i]大于 0,则三数之和必然无法等于 0,结束循环
如果 nums[i] =nums[i−1],则说明该数字重复,会导致结果重复,所以应该跳过
当 sum=0 时,nums[L]= nums[L+1] 则会导致结果重复,应该跳过,L++
当 sum= 0 时,nums[R]= nums[R−1]则会导致结果重复,应该跳过,R−−
class Solution {
public static List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> ans = new ArrayList();
int len = nums.length;
if(nums == null || len < 3) return ans;
Arrays.sort(nums); // 排序
for (int i = 0; i < len ; i++) {
if(nums[i] > 0) break; // 如果当前数字大于0,则三数之和一定大于0,所以结束循环
if(i > 0 && nums[i] == nums[i-1]) continue; // 去重
int L = i+1;
int R = len-1;
while(L < R){
int sum = nums[i] + nums[L] + nums[R];
if(sum == 0){
ans.add(Arrays.asList(nums[i],nums[L],nums[R]));
while (L<R && nums[L] == nums[L+1]) L++; // 去重
while (L<R && nums[R] == nums[R-1]) R--; // 去重
L++;
R--;
}
else if (sum < 0) L++;
else if (sum > 0) R--;
}
}
return ans;
}
}
解法3(别人的)
首先是求解:因为要求3个数,如果我们固定其中1个数,再用求“和为某值的2个数的组合”的解法,就能把剩下的2个数求出来。因
此,先对数组进行非递减排序,这样整个数组的数就由小到大排列。i 的取值由 0 至 n-1,对每一个i,我们求当num[i]是解当中的其
中一个数时,其他的2个数。设有指针p指向数组头(实际只要p从i+1开始),q指向数组尾,sum = num[i] + num[p]+ num[q],因为num[i]
是一定在解中的,所以如果sum < 0,因为num[q]已经不能增大,所以说明num[p]太小了,这时p需要向后移动,找一个更大的数。
同理,sum > 0,说明num[q]太大了,需要q向前移动。当sum == 0时,说明找到了一个解。但找到了一个解,并不说明解中有num[i]的
所有解都找到了,因此p或q还需要继续移动寻找其他的解,直到p == q为止。
上面是求解的过程,那么去重怎么做?去重就在于和之前的解进行比较,但我们不需要比较所有的解,这里有一个技巧。
-
如果num[i] = num[i - 1],说明刚才i-1时求的解在这次肯定也会求出一样的,所以直接跳过不求;
-
其实指针p不需要从数组头开始,因为如果num[i]所在的解中如果有i之前的数,设其位置为j,那么我们求num[j]时,肯定把num[i]
也找出来放到和num[j]一起的解里了,所以指针p其实应该从i+1开始,即初始时p = i + 1, q = num.size() - 1;
-
当sum == 0,我们保存了当前解以后,需要num[i]在解中的其他的2个数组合,这个时候,肯定是p往后或者q往前,如果++p,发现其实num[p] == num[p-1],说明这个解肯定和刚才重复了,再继续++p。同理,如果–q后发现num[q] == num[q+1],继续–q。
这个去重操作主要针对这种有多个同值的数组,如:-3, 1,1,1, 2,2,3,4。
public class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> list = new ArrayList<List<Integer>>();
int n = nums.length;
Arrays.sort(nums);
for(int i=0;i<n;i++){
if(i!=0 && nums[i]==nums[i-1]) continue;
int sum = 0;
int p = i+1,q = n-1;
while(p<q){
sum = nums[i]+nums[p]+nums[q];
if(sum==0){
List<Integer> item = new ArrayList<Integer>();
item.add(nums[i]);
item.add(nums[p]);
item.add(nums[q]);
list.add(item);
while(++p<q && nums[p-1]==nums[p]){
}
while(--q>p && nums[q+1]==nums[q]){
}
}
else if(sum>0){
q--;
}
else{
p++;
}
}
}
return list;
}
}
解法4(成功,60ms,较慢)
先对数组进行排序,再用hashmap统计数组中每个数字对应的次数。然后i从0到length-1循环,j从i到length-1循环,另一个numK为-numI-numJ,从hashmap计算是否存在,且保证下标i<j<k,i,j循环的时候调用getNextIndex,得到下一个与前一个数字不同的下标,这样保证得到的结果不重复。
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result=new ArrayList<>();
List<Integer> now=new ArrayList<>();
//给数组排序
Arrays.sort(nums);
//数组长度
int length=nums.length;
HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
for(int num:nums) {
map.put(num, map.getOrDefault(num, 0)+1);
}
int i=0;
while(i<length) {
int numI = nums[i];
int j=i+1;
while(j<length) {
int numJ = nums[j];
int numK = -numI - numJ;
if(numK < numJ) {
break;
}
int same = 1;
if(numI == numK) {
same++;
}
if(numJ == numK) {
same++;
}
if(map.getOrDefault(numK,0)>=same) {
now.add(numI);
now.add(numJ);
now.add(numK);
result.add(now);
now=new ArrayList<>();
}
j = getNextIndex(nums, j);
}
i = getNextIndex(nums, i);
}
return result;
}
private int getNextIndex(int[] nums,int i) {
int now = nums[i];
while(i<nums.length) {
if(nums[i] != now) {
return i;
}else {
i++;
}
}
return i;
}