leetcode-15. 三數之和等於0

 

給你一個包含 n 個整數的數組 nums，判斷 nums 中是否存在三個元素 a，b，c ，使得 a + b + c = 0 ？請你找出所有滿足條件且不重複的三元組。

注意：答案中不可以包含重複的三元組。

示例：

給定數組 nums = [-1, 0, 1, 2, -1, -4]，

滿足要求的三元組集合爲：
[
  [-1, 0, 1],
  [-1, -1, 2]
]

 

class Solution {

    public List<List<Integer>> threeSum(int[] nums) {
        // 數組長度小於3 返回空數組
        if (nums.length < 3) {
            return Collections.emptyList();
        }
        List<List<Integer>> res = new ArrayList<>();
        int minValue = Integer.MAX_VALUE;
        int maxValue = Integer.MIN_VALUE;
        int negSize = 0;
        int posSize = 0;
        int zeroSize = 0;
        for (int v : nums) {
            // 取數組中的最小值
            if (v < minValue) {
                minValue = v;
            }
            // 取數組中的最大值
            if (v > maxValue) {
                maxValue = v;
            }
            if (v > 0) {
                // 大於0的數字數量
                posSize++;
            } else if (v < 0) {
                // 小於0的數字數量
                negSize++;
            } else {
                // 0的數量
                zeroSize++;
            }
        }
        // 如果爲0 的數量大於等於3個那麼就添加一個三個0的數組，因爲不可重複 所以加一個就可以
        if (zeroSize >= 3) {
            res.add(Arrays.asList(0, 0, 0));
        }
        // 如果大於小於0的數量都是0個 那麼說明裏面全是0 直接返回結果對象
        if (negSize == 0 || posSize == 0) {
            return res;
        }
        if (minValue * 2 + maxValue > 0) {
            // 縮小最大值取值範圍 minValue應該是負數， *2 + max如果還大於說明最大值取值過大，無意義
            maxValue = -minValue * 2;

        } else if (maxValue * 2 + minValue < 0) {
            // 同理縮小最小值取值範圍
            minValue = -maxValue * 2;
        }
        int[] map = new int[maxValue - minValue + 1];
        int[] negs = new int[negSize];
        int[] poses = new int[posSize];
        negSize = 0;
        posSize = 0;
        for (int v : nums) {
            // 循環數組，判斷當前元素在取值範圍內
            if (v >= minValue && v <= maxValue) {
                // int數組所有位置都爲0 所以判斷 == 0時這個結果就肯定沒有計算過 ++ 是爲了添加訪問標識
                if (map[v - minValue]++ == 0) {
                    if (v > 0) {
                        // 存放所有大於0的元素
                        poses[posSize++] = v;
                    } else if (v < 0) {
                        // 存儲所有小於0的元素
                        negs[negSize++] = v;
                    }
                }
            }
        }
        // 排序大於0的數組
        Arrays.sort(poses, 0, posSize);
        // 排序小於0的數組
        Arrays.sort(negs, 0, negSize);
        int basej = 0;
        for (int i = negSize - 1; i >= 0; i--) {
            int nv = negs[i];
            int minp = (-nv) >>> 1;
            // 進一步縮小大於0的數組的取值範圍
            while (basej < posSize && poses[basej] < minp) {
                basej++;
            }
            for (int j = basej; j < posSize; j++) {
                int pv = poses[j];
                // nv 是負數 0 - nv = 正數 pv 是正數
                // 得出 cv
                int cv = 0 - nv - pv;
                // cv 如果大於等於這個負數 並且小於等於這個負數 說明這個數字有可能滿足題目條件
                if (cv >= nv && cv <= pv) {
                    if (cv == nv) {
                        // 如果cv = nv 並且這個值存在超過2個 則添加到結果集中 否則跳過
                        if (map[nv - minValue] > 1) {
                            res.add(Arrays.asList(nv, nv, pv));
                        }
                    } else if (cv == pv) {
                        // 如果cv = pv 並且這個值存在超過2個 則添加到結果集中 否則跳過
                        if (map[pv - minValue] > 1) {
                            res.add(Arrays.asList(nv, pv, pv));
                        }
                    } else if (map[cv - minValue] > 0) {
                        // 這個值存在過，那麼最小值 最大值 和當前元素 添加到結構集中 否則跳過
                        res.add(Arrays.asList(nv, cv, pv));
                    }
                } else if (cv < nv) {
                    // 如果cv 校友最小取值 說明後面也沒有符合條件的數字了  直接結束循環
                    break;
                }
            }
        }
        return res;
    }
}

 

執行用時：9 ms

內存消耗：44.4 MB