四数之和(Java)

给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：
答案中不可以包含重复的四元组。

示例：
给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。

满足要求的四元组集合为：
[
  [-1,  0, 0, 1],
  [-2, -1, 1, 2],
  [-2,  0, 0, 2]
]

方法一：最朴素的方法是使用四重循环枚举所有的四元组，然后使用哈希表进行去重操作，得到不包含重复四元组的最终答案。

方法二：排序 + 双指针
1、对数组进行排序
2、每一种循环枚举到的下标必须大于上一重循环枚举到的下标；同一重循环中，如果当前元素与上一个元素相同，则跳过当前元素
3、使用两重循环分别枚举前两个数，然后在两重循环枚举到的数之后使用双指针枚举剩下的两个数。假设两重循环枚举到的前两个数分别位于下标 i 和 j，其中 i<j。初始时，左右指针分别指向下标 j+1 和下标 n−1。每次计算四个数的和，并进行如下操作：
A、如果和等于 target，则将枚举到的四个数加到答案中，然后将左指针右移直到遇到不同的数，将右指针左移直到遇到不同的数
B、如果和小于 target，则将左指针右移一位
C、如果和大于 target，则将右指针左移一位
4、进行一些剪枝

package com.loo;

import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;

public class FourNumberSum {
    public static void main(String[] args) {
        int[] arr = new int[] {1, 0, -1, 0, -2, 2};
        int target = 0;
        List<List<Integer>> list = fourNumberSum(arr , target);
        for (List<Integer> l : list) {
            System.out.println(l);
        }
    }

    public static List<List<Integer>> fourNumberSum(int[] arr , int target) {
        List<List<Integer>> results = new ArrayList<List<Integer>>();
        if (arr == null || arr.length < 4) {
            return results;
        }
        Arrays.sort(arr);
        int length = arr.length;
        for (int i=0;i<length-3;i++) {
            // 剪枝，遇到相同的忽略，继续下一个数
            if (i>0 && arr[i] == arr[i-1]) {
                continue;
            }
            // 剪枝，因为数组已经排好序，所以如果 arr[i] + arr[i+1] + arr[i+2] + arr[i+3] > target 条件成立，说明后面的元素没有符合的了
            if (arr[i] + arr[i+1] + arr[i+2] + arr[i+3] > target) {
                break;
            }
            // 剪枝，数组最后面三个值已经固定，如果后面三个最大的值加起来再加上一个arr[i]都不能大于target，那么继续下一个元素i+1
            if (arr[i] + arr[length-3] + arr[length-2] + arr[length-1]<target) {
                continue;
            }
            for (int j=i+1;j<length-2;j++) {
                if (j>i+1 && arr[j]==arr[j-1]) {
                    continue;
                }
                if (arr[i] + arr[j] + arr[j+1] + arr[j+2] > target) {
                    break;
                }
                if (arr[i] + arr[j] + arr[length-2] + arr[length-1] < target) {
                    continue;
                }
                // 双指针
                int left = j+1;
                int right = length - 1;
                while (left < right) {
                    int sum = arr[i] + arr[j] + arr[left] + arr[right];
                    if (sum == target) {
                        results.add(Arrays.asList(arr[i] , arr[j] , arr[left] , arr[right]));
                        while (left<right && arr[left]==arr[left+1]) {
                            left++;
                        }
                        left++;
                        while (left<right && arr[right]==arr[right-1]) {
                            right--;
                        }
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        right--;
                    }
                }
            }
        }
        return results;
    }
}