18. 四数之和（java实现）--2种解法（双指针，hash）LeetCode

题目：

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案 。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

提示：

1 <= nums.length <= 200
-10^9 <= nums[i] <= 10^9
-10^9 <= target <= 10^9

解法1：双指针

    /**
     * 思路：
     * 把4数和转变为3数和
     * 数组排序
     * 先确定第一个数，如果当前i!=0&&nums[i]==nums[i-1]数据重复，移动下标
     * 确定一个数后就变成了3数和的问题了
     * 确定第二个数，确定左右指针，如果当前j!=i+1&&nums[j]==nums[j-1]数据重复，移动下标
     * 之后不断的移动左右指针，寻找4数和为target的组合
     * sum>target，因为是排序数组，移动右侧指针，让sum变小
     * sum<target，反之
     * sum==target，加入结果集，移动l和r，判断l和r是否和下一个位置元素重复，重复就进行移动。
     */
    public static List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        for (int i=0;i<nums.length-3;i++){
            if (i==0||nums[i]!=nums[i-1]){
                for (int j=i+1;j<nums.length-2;j++){
                    int l=j+1,r=nums.length-1;
                    if (j==i+1||nums[j]!=nums[j-1]){
                        while (r>l) {
                            int sum = nums[i] + nums[j] + nums[l] + nums[r];
                            if (sum > target) {
                                r--;
                            } else if (sum < target) {
                                l++;
                            } else {
                                result.add(Arrays.asList(nums[i] , nums[j] , nums[l] , nums[r]));
                                while (r>l&&nums[l]==nums[++l]){
                                }
                                while (r>l&&nums[r]==nums[--r]){
                                }
                            }
                        }
                    }
                }
            }
        }
        return result;
    }

时间复杂度：On^3

空间复杂度：On

解法2：hash

    /**
     * 思路：
     * 确定2个数的所有组合，每确定一个前2个数的组合就创建一个map
     * 向前遍历去找剩下的2个数，不存在就放入map，存在就进行记录
     *      排序后放入set进行去重
     */
    public static List<List<Integer>> fourSum(int[] nums, int target) {
        HashSet<List<Integer>> set = new HashSet<>();
        for (int i = 0; i < nums.length - 3; i++) {
            for (int j = i + 1; j < nums.length - 2; j++) {
                HashMap<Integer, Integer> map = new HashMap<>();
                for (int k = j + 1; k < nums.length; k++) {
                    int need = target-(nums[i] + nums[j]+nums[k]);
                    if (map.containsKey(need)) {
                        List<Integer> list = Arrays.asList(nums[i], nums[j],nums[k], need);
                        Collections.sort(list);
                        set.add(list);
                    } else {
                        map.put(nums[k], nums[k]);
                    }
                }
            }
        }
        return new ArrayList<>(set);
    }

时间复杂度：On^3logn

空间复杂度：On