力扣（LeetCode） 15.三数之和（java）

题目

方法一：排序+指针

public class ThreeSum {

    public List<List<Integer>> threeSum(int[] nums) {
        //类似两数之和
        //排序+指针
        //先由小到大排序
        Arrays.sort(nums);
        //最笨的方法三层嵌套循环
        //改进：
        //1、由 i != j、i != k 且 j != k 可知，三层循环起始位置第一层为nums[0]，则第二层为nums[1]，则第三层为nums[2]，同一个数不能同时存在。
        //2、nums[i] + nums[j] + nums[k] == 0 可知，在第一层已确认的情况下，循环时第二层逐渐变大则第三层只能逐渐变小（已经排序）。
        //3、结合指针的思想，可省略第三层的循环。
        List<List<Integer>> lists = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {//第一层
            if (i > 0 && nums[i] == nums[i-1]) {
                continue;
            }
            int a = nums[i];
            int k = nums.length-1;
            for (int j = i + 1; j < nums.length; j++) {//第二层
                if (j > i+1 && nums[j] == nums[j-1]) {
                    continue;
                }
                int b = nums[j];
                //好比第三层，b是不断变大的，故c即nums[k]满足条件的只能越来越小，
                //所以k不必每次都从数组最后开始遍历，直接从j-1循环的最后值开始，所以是>0而不是!=0。!=0会出现k--直接到了j==k。
                while (j<k && a+b+nums[k]>0) {
                    k--;                      
                }
                if (j==k) {
                    break;
                }
                if (a+b+nums[k]==0) {
                    List<Integer> list = new ArrayList<>();
                    list.add(nums[i]);
                    list.add(nums[j]);
                    list.add(nums[k]);
                    lists.add(list);
                }
            }
        }
        return lists;
    }

    public static void main(String[] args) {
        ThreeSum threeSum = new ThreeSum();
        //int[] nums = {-1,0,1,2,-1,-4};
        //int[] nums = {0,1,1};
        int[] nums = {0,0,0};
        System.out.println(threeSum.threeSum(nums));
    }
}

 LeetCode测试结果

 方法二：排序+双指针

public class ThreeSum {

    public static void main(String[] args) {
        ThreeSum threeSum = new ThreeSum();
        int[] nums = {-1,0,1,2,-1,-4};
        //int[] nums = {0,1,1};
        //int[] nums = {0,0,0};
        System.out.println(threeSum.threeSum(nums));
    }

    public List<List<Integer>> threeSum(int[] nums) {
        //类似两数之和
        //排序+双指针，再减少一层嵌套循环
        //先由小到大排序
        Arrays.sort(nums);
        //改进：
        //1、由 i != j、i != k 且 j != k 可知，三层循环起始位置第一层为nums[0]，则第二层为nums[1]，则第三层为nums[2]，同一个数不能同时存在。
        //2、nums[i] + nums[j] + nums[k] == 0 可知，在第一层已确认的情况下，循环时第二层逐渐变大则第三层只能逐渐变小（已经排序）。
        //3、结合双指针的思想，可省略第二第三层的循环。
        List<List<Integer>> lists = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {//第一层
            if (i > 0 && nums[i] == nums[i-1]) {
                continue;
            }
            int a = nums[i];
            int h = i+1;
            int k = nums.length-1;
            while (h<k) {
                if (a+nums[h]+nums[k]>0) {
                    k--;
                } else if (a+nums[h]+nums[k]<0) {
                    h++;
                } else {
                    List<Integer> list = new ArrayList<>();
                    list.add(nums[i]);
                    list.add(nums[h]);
                    list.add(nums[k]);
                    lists.add(list);
                    k--;
                    h++;
                    while (h<k && nums[h]==nums[h-1]) {
                        h++;
                    }
                    while (h<k && nums[k]==nums[k+1]) {
                        k--;
                    }
                }

            }
        }
        return lists;
    }

}

LeetCode测试结果