LeetCode15.三數之和

給你一個包含 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.*;

/**
 * @author mac
 * @date 2020/11/5-22:57
 */
public class t15_三數之和 {
    /**
     * 遍歷+雙指標法
     * 時間複雜度：O(n^2)，陣列排序 O(NlogN)，遍歷陣列 O(n)， 雙指標遍歷 O(n)
     * 總體 O(NlogN)+O(n)∗O(n)=O(n2)
     *
     * @param nums
     * @return
     */
    public List<List<Integer>> threeSum(int[] nums) {
        // 對陣列進行排序
        Arrays.sort(nums);
        // 建立返回物件
        List<List<Integer>> res = new ArrayList<>();
        // 迴圈遍歷陣列，因為是三數和，所以做後一個判斷陣列nums倒數第三個就可以了，故k < nums.length - 2
        for (int k = 0; k < nums.length - 2; k++) {
            // 如果陣列大於0了，就證明後面沒有負數（提前排序過），那就不可能相加為0，故直接返回
            if (nums[k] > 0) {
                break;
            }
            // 遍歷第一個數時0<1，k-1就小於0，故有k > 0 ，前一個和後一個想等的話，那麼只判斷後面的就可以了，兩個都判斷如果有三數和為0，接過重複
            if (k > 0 && nums[k] == nums[k - 1]) {
                continue;
            }
            // i指標1在k前一位，j指標有最後一位
            int i = k + 1, j = nums.length - 1;
            // 如果大於等於j，那麼證明兩個指標碰撞了，就不需要繼續判斷三數之和了
            while (i < j) {
                // 三數相加
                int sum = nums[k] + nums[i] + nums[j];
                // 因為最開始是排序過的，如果三數和小於0，那麼i需要右→移去更大的數
                if (sum < 0) {
                    // 如i和i右面的數相同，就沒有再去判斷的必要了
                    while (i < j && nums[i] == nums[++i]) ;
                }
                // // 因為最開始是排序過的，如果三數和大於0，那麼j需要左←移去更小的數
                else if (sum > 0) {
                    // 如j和j左面的數相同，就沒有再去判斷的必要了
                    while (i < j && nums[j] == nums[--j]) ;
                } else {
                    // 滿足三數和為0,存放在結果集中
                    res.add(new ArrayList<Integer>(Arrays.asList(nums[k], nums[i], nums[j])));
                    // 可能存在多組解，同時去除重複接，並同時將 i，j移到下一位置，尋找新的解
                    while (i < j && nums[i] == nums[++i]) ;
                    while (i < j && nums[j] == nums[--j]) ;
                }
            }
        }
        return res;
    }


    /**
     * 超出時間限制，時間複雜度 O(n^2)
     * 雙重暴力+hash
     */
    public static List<List<Integer>> threeSum1(int[] nums) {
        // 如果陣列的長度小於2，一定沒有滿足條件的集合
        if (nums == null || nums.length <= 2) {
            return Collections.emptyList();
        }
        // 排序
        Arrays.sort(nums);

        // 使用Set防重，對結果防重
        Set<List<Integer>> result = new LinkedHashSet<>();

        // 遍歷陣列
        for (int i = 0; i < nums.length - 2; i++) {
            // 使用Hash表儲存資料，
            Map<Integer, Integer> hashMap = new HashMap<>();
            for (int j = i + 1; j < nums.length; j++) {
                // 如果為沒有兩數之和等於第三個數的相反數，就不滿足三數之和為0的條件
                if (hashMap.get(-nums[i] - nums[j]) != null) {
                    // 把滿足條件資料生成集合
                    List<Integer> list = Arrays.asList(nums[i], hashMap.get(-nums[i] - nums[j]), nums[j]);
                    // 對集合進行排序，防止 [1,0,-1] [-1,0,1]去不掉
                    Collections.sort(list);
                    // 放入Set中，對結果進行去重
                    result.add(list);
                } else {
                    // 將不滿足的條件的儲存在hash表中（有可能是資料不夠，或者沒有滿足條件的資料）
                    hashMap.put(nums[j], nums[j]);
                }
            }
        }
        // 轉成集合返回
        return new ArrayList<>(result);
    }

    /**
     * 超出時間限制，時間複雜度 O(n^3)
     */
    public static List<List<Integer>> threeSum2(int[] nums) {
        // 如果陣列的長度小於2，一定沒有滿足條件的集合
        if (nums == null || nums.length <= 2) {
            return Collections.emptyList();
        }
        // 排序
        // 使用Set防重，對結果防重
        Set<List<Integer>> result = new LinkedHashSet<>();
        // 三重for迴圈
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                for (int k = j + 1; k < nums.length; k++) {
                    // 如果滿足三數和是0
                    if (nums[i] + nums[j] + nums[k] == 0) {
                        // 把滿足條件資料生成集合
                        List<Integer> value = Arrays.asList(nums[i], nums[j], nums[k]);
                        // 放入Set中
                        result.add(value);
                    }
                }
            }
        }
        // 轉成集合返回
        return new ArrayList<>(result);
    }
}