【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存儲空間。