双指针4.三数之和/三数最接近之和/n数之和（异向指针）

输出一个数组中三个数加起来等于0的所有数组，不允许有重复。
可以想到最简单的方式就是三层循环遍历所有的组合，但是这样会有重复，所以在遍历之前需要对数组排序，排序之后再开始遍历，如果发现一样则跳过。
还可以发现第二层循环确定之后，其实第三层循环只有一个数需要确定，也就是j确定之后第三个数其实已经确定了，所以在每个j循环之前都定义一个变量在数组最右端，当此时三数相加不等于0时就three–，直到相加为0则j++，也就是j和three在确定i的情况下会遍历一遍数组。所以时间复杂度为O（n2）
空间复杂度为O（）。

import java.util.ArrayList;
import java.util.Arrays;
class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res=new ArrayList<List<Integer>>();
        if(nums==null || nums.length<3)return res;
        Arrays.sort(nums);
        for(int i=0;i<nums.length;i++){
            if(i>0 && nums[i]==nums[i-1])continue;
            int three=nums.length-1;
            for(int j=i+1;j<nums.length;j++){
                if(j>i+1 && nums[j]==nums[j-1])continue;
                while(three>j && nums[i]+nums[j]+nums[three]>0){
                    three--;
                }
                if(three==j){
                    break;
                }
                 if(nums[i]+nums[j]+nums[three]==0){
                    List<Integer> list=new ArrayList<Integer>();
                    list.add(nums[i]);
                    list.add(nums[j]);
                    list.add(nums[three]);
                    res.add(list);
                }
            }
        }
        return res;
    }   
}

返回数组中最接近target的三个数的和。

import java.util.Arrays;
class Solution {
    public int threeSumClosest(int[] nums, int target) {
        if(nums==null || nums.length<3)return 0;
        Arrays.sort(nums);
        int min=Integer.MAX_VALUE;
        int res=0;
        for(int i=0;i<nums.length;i++){
            if(i>0 && nums[i]==nums[i-1])continue;
            int three=nums.length-1;
            int j=i+1;
            while(three>j){
                if(j>i+1 && nums[j]==nums[j-1]){
                    j++;
                    continue;
                }
                if(nums[i]+nums[j]+nums[three]==target){
                    return target;
                }
                if(Math.abs(nums[i]+nums[j]+nums[three]-target)<min){
                        min=Math.abs(nums[i]+nums[j]+nums[three]-target);
                        res=nums[i]+nums[j]+nums[three];
                 }
                if(nums[i]+nums[j]+nums[three]<target){
                    j++;
                }else{
                     three--;
                }
            }
        }
        return res;
    }
}

如果要求4个数的和等于target，只要先排序，然后三层for循环，最后一层与第四个数是同一层的，利用双指针确定。复杂度为O（n3）
由此可见n数之和也只要排序，然后n-1层循环即可。