【LeetCode系列】三数之和等于固定数 3Sum

题目描述： LeetCode题目原地址
Given an array nums of n integers, are there elements a, b, c in nums such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.
给定一个包含n个整数的数组nums，判断nums中是否存在三个元素a, b, c，使得a + b + c = 0？找到所有满足条件且不重复的三元组。

例如： 给定一个数组 nums = [-1, 0, 1, 2, -1, -4]
满足条件的方案为：

[
    [-1, 0, 1],
    [-1, -1, 2]
]

解法一： 三个数的和为指定数（即0），可以考虑先固定一个数nums[i]，在剩下的数组中找两个数相加等于target = -nums[i]的数即可，则问题转化为：求两个数之和为target的数，很容易想到Two Sum这一题，用HashMap的求解，详细解答之前有过一篇博文。由于原文要求不可重复，可将HaspMap改成HashSet。
代码一：

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> list = new LinkedList<>();
        Arrays.sort(nums);
        for(int i = 0;i< nums.length-2;i++){
            if(i > 0 && nums[i] == nums[i-1]) continue
            twoSum(list, nums, i+1,nums.length-1,-nums[i]);
        }
        return list;
    }
    private void twoSum(List<List<Integer>> list, int[] nums,int low,int high,int target){
        if(low > high) return;
        HashSet<Integer> set = new HashSet<>();
        for(int i = low;i<= high;i++){
            if(set.contains(target - nums[i])) {
                list.add(Arrays.asList(-target,nums[i],target-nums[i]));
                while(i+1 <= high && nums[i] == nums[i+1]) i++;
            }else{
                set.add(nums[i]);
            }
        }
    }
}

解法二： 沿用解法一种的找两个数之和为target的思想，如何找到两个数之和为target呢？最直接的想法是遍历所有两个数的组合（可想而知时间复杂度过高），我们知道对有序数组而言，可以用双指针遍历任意可能的两个元素对（以线性时间复杂度）。因此可以考虑先将数组排序，然后定义left和right为分别表示从nums[i]之后开始的数组的第一个数和最后一个数。
left从左向右开始遍历，right从右向左开始遍历，因为是排序了的数组，nums[left] <= nums[right]是一定的。计算每个sum = nums[left] + nums[right]，与需要求的数target比较，如果比target小，说明需要一个大一点的数以靠近target，设left++（因为nums[left] <= nums[left + 1]是肯定的）；同理，如果比target大，设right--；如果刚好与target相等，说明nums[i]、nums[left]、nums[right]为满足条件的三个数。

注意：

1. 在依固定数nums[i]循环时，如果nums[i] > 0，说明后面的数都大于0，即不可能再出现两数之和等于-nums[i]的情况了，应该直接退出循环。
2. 需要跳过nums[i]相等的情况，因为题目中的要求为不重复的三元组。
3. 同理，left和right也需要跳过重复的数。

代码二：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;  //存储结果：多维向量
        //先对数组进行从小到大排序
        sort(nums.begin(), nums.end());
        //从头到尾遍历一个固定的数fix，在剩下的数中找两数之和为-fix的数
        for(int i = 0; i < nums.size(); i++){
            //如果fix已经是大于零了，说明后面的数也是大于0，不可能再出现与fix相加等于零的两个数了
            if(nums[i] > 0){
                break;
            }
            //如果基准数fix一样则直接进行下一次循环
            //如果不加这一行会有重复的值
            if(i == 0 || (i > 0 && nums[i] != nums[i -1])){
                //要找的两数之和的目标值，fix即为nums[i]
                int target = -nums[i];
                //定义一个左指针和右指针分别表示从fix之后开始的数组收尾两个数
                int left = i + 1;
                int right = nums.size() - 1;
                while(left < right){
                    int sum = nums[left] + nums[right];
                    //如果两数之和小于target，则左指针右移一位，使得左指针指向的数字增大一点，靠近target
                    if(sum < target){
                        left++;
                        //如果两数之和小于target，则左指针右移一位，使得左指针指向的数字增大一点，靠近target
                    }else if(sum > target){
                        right--;
                    }else{
                        //存储某一个结果
                        result.push_back({nums[i], nums[left], nums[right]});
                        //需要继续找下一个可能结果，跳过重复数字（不管它是不是结果，只要扫描过都跳过）
                        while(left < right && nums[left] == nums[left + 1]){
                            left++;
                        }
                        while(left < right && nums[right] == nums[right - 1]){
                            right--;
                        }
                        left++; right--;
                    }
                }
            }
        }
        return result;
    }
};

结果比较：
由下图可以明显看到解法二比解法一不仅用的时间更短，内存也更少。原因是解法一中除用LinkedList存储结果集外，每一个nums[i]还需要用新的HashSet存储空间。