数组练习练习题02--三数之和

三数之和：
     给你一个包含n个整数的数组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]
输出：[]

方法1：排序加双指针
思路：
题目要求找到所有的不重复且和为0的三元组，这个[不重复]的要求使得我们无法简单的使用使用三重循环枚举所有的三元组。因为在最坏的情况下，数组中的所有元素都为0，即

[0, 0, 0, 0, 0, ..., 0, 0, 0]

任意一个三元组的和都为0.如果我们直接使用三重循环枚举三元组，会得到O(N³)个满足题目要求的三元组(其中N数数组长度)，时间复杂度至少为O(N³)。在这之后，我们还需要使用哈希表去重操作，得到不包含重复三元组的最终答案，又消耗大量时间。这个做法的视觉复杂度和空间复杂度都很高，因此我们要换一种思路来考虑这个问题。
[不重复]的本质是什么？我们保持三重 循环的大框架不变，只需要保证：

• 第二重循环枚举到的元素不小于当前第一重循环枚举到的元素
• 第三重循环枚举到的元素，不小于当前第二重循环枚举到的元素
  也就是说，我们枚举到的三元组(a,b,c)满足a<=b<=c，保证了只有(a,b,c)这个顺序会被枚举到，而(b,a,c),(c,b,a)等等不会，这样就减少了重复。要实现这点，我们可以将数组中的元素怒从小到大排序，随后使用普通的的三重循环就可以满足上面的要求。
  同时，对于每一重循环，相邻两次枚举到的元素不能相同，否则也会造成重复。举个例子，如果排序完的数字为

[0, 1, 2, 2, 2, 3]

我们使用三重循环枚举到第一个三元组(0,1,2),如果第三重循环继续枚举下一个元素，那么仍然是三元组(0,1,2)，产生了重复。因此我们需要将第三重循环[跳到]下一个不相同元素，即数组中的最后一个元素，枚举三元组(0,1,3)
下面给出改进方法的伪代码实现：

nums.sort()
for first = 0 .. n-1
    // 只有和上一次枚举的元素不相同，我们才会进行枚举
    if first == 0 or nums[first] != nums[first-1] then
        for second = first+1 .. n-1
            if second == first+1 or nums[second] != nums[second-1] then
                for third = second+1 .. n-1
                    if third == second+1 or nums[third] != nums[third-1] then
                        // 判断是否有 a+b+c==0
                        check(first, second, third)

这种方法的时间复杂度仍然为O(N³)，毕竟我们还没有跳出三重稀罕的大框架，然而他是很容易优化的，可以发现，如果我们固定了前二重循环枚举到的元素a和b，那么只有唯一的c满足a+b+c=0.当第二重循环往后枚举一个元素b1时，由于b1>b，那么满足a+b1+c1=0的c1一定有c1>c，即c1在数组中一定出现在c的左侧，也就是说，我们可以从小到大枚举b，同时从大到小枚举c，即第二重循环和第三重循环实际上是并列的关系。
有了这样的发现，我们就可以保持第二重循环不变，将第三重循环变成一个从右端开始向左移动的指针，从而得到这样的伪代码：

nums.sort()
for first = 0 .. n-1
    if first == 0 or nums[first] != nums[first-1] then
        // 第三重循环对应的指针
        third = n-1
        for second = first+1 .. n-1
            if second == first+1 or nums[second] != nums[second-1] then
                // 向左移动指针，直到 a+b+c 不大于 0
                while nums[first]+nums[second]+nums[third] > 0
                    third = third-1
                // 判断是否有 a+b+c==0
                check(first, second, third)

这个方法就是我们常说的「双指针」，当我们需要枚举数组中的两个元素时，如果我们发现随着第一个元素的递增，第二个元素是递减的，那么就可以使用双指针的方法，将枚举的时间复杂度从 O(N²)减少至 O(N)。为什么是 O(N) 呢？这是因为在枚举的过程每一步中，「左指针」会向右移动一个位置（也就是题目中的 b），而「右指针」会向左移动若干个位置，这个与数组的元素有关，但我们知道它一共会移动的位置数为 O(N)，均摊下来，每次也向左移动一个位置，因此时间复杂度为 O(N)。

注意到我们的伪代码中还有第一重循环，时间复杂度为 O(N)，因此枚举的总时间复杂度为O(N²)。由于排序的时间复杂度为 O(Nlog⁡N)，在渐进意义下小于前者，因此算法的总时间复杂度为 O(N²)。

上述的伪代码中还有一些细节需要补充，例如我们需要保持左指针一直在右指针的左侧（即满足 b≤c），具体可以参考下面的代码，均给出了详细的注释。

以上文字题解来自于leetcode官方题解

https://leetcode-cn.com/problems/3sum/solution/san-shu-zhi-he-by-leetcode-solution/

代码：

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {// 总时间复杂度：O(n^2)
    List<List<Integer>> threeSum(int[] nums){
    	List<List<Integer>> ans=new ArrayList<>();
    	if(nums==null||nums.length<=2)
    		return ans;
    	Arrays.sort(nums);
    	for(int i=0;i<nums.length-2;i++){
    		if(nums[i]>0)//第一个数大于0，后面数都比它大，肯定不成立
    			break;
    		if(i>0&&nums[i]==nums[i-1])//去掉重复元素
    			continue;
    		int low=i+1,high=nums.length-1;
    		while(low<high){
    			if(nums[low]+nums[high]==-nums[i]){
    				ans.add(new Arrays.asList(nums[i],nums[low],nums[high]));
    				//现在需要增加low，减少high，但是不能重复，比如: [-2, -1, -1, -1, 3, 3, 3], i = 0, left = 1, right = 6, [-2, -1, 3] 的答案加入后，需要排除重复的 -1 和 3
    				low++;high--;//首先无论如何都要进行加减操作
    				while(low<high&&nums[low]==nums[low-1])
    					low++;
    				while(low<high&&nums[high]==[high+1])
    					high--;
    			}
    			else if(nums[low]+nums[high]<-nums[i]){
    				low++;
    			}
    			else{
    				high--;
    			}
    		}
    		return ans;
    	}
    }