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