力扣记录：哈希表——454 四数相加II，15 三数之和，18 四数之和

本次题目

• 454 四数相加II
• 15 三数之和
• 18 四数之和

454 四数相加II

• Map作为哈希表：四个独立的数组，不用考虑出现重复，返回和为0的次数，使用哈希表HashMap，key为两数和，value为两数之和出现的次数。将四个数组分为两组求和，同上进行判断。
• 定义一个HashMap，存储数组1和2的元素之和及出现的次数；然后遍历数组3和4，判断0-(3和4之和)是否在HashMap中，若存在，则进行统计，次数为HashMap对应key的value。

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        //定义HashMap
        Map<Integer, Integer> map1 = new HashMap<>();
        //定义输出结果
        int res = 0;
        //遍历数组1，2并求和后存进HashMap
        for(int i : nums1){
            for(int j : nums2){
                if(!map1.containsKey(i+j)){
                    map1.put(i+j, 0);
                }
                map1.put(i+j, map1.get(i+j)+1);
            }
        }
        //遍历数组3，4并判断
        for(int i : nums3){
            for(int j : nums4){
                if(map1.containsKey(-i-j)){
                    res += map1.get(-i-j);
                }
            }
        }
        return res;
    }
}

15 三数之和

• 同一个数组中找出三个元素和为0，但是三个元素不能重复，因此使用哈希表的话去重十分麻烦，建议使用双指针法。
• 首先将数组升序排序，使用i遍历数组，左指针指向i+1，右指针指向数组最右端，若i与左右指针指向数之和大于0，则右指针向左移动；若小于0，则左指针向右移动；若等于0则存储三个值（注意存储后需要进行去重），直到左右指针相遇进入下一轮循环。
• 注意：
  1. 排序后可以判断i指向的数是否大于0，若大于0则可以直接返回结果。
  2. 在求和前去重，若i指向的数与上一个数相同，最后得到的组合与上一个组合一致，因此跳过该数。
  3. 数组升序排序Arrays.sort()；将数组转为List集合Arrays.asList()。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        //将数组升序排序
        Arrays.sort(nums);
        //定义List存储结果
        List<List<Integer>> res = new ArrayList<>();


        //遍历数组
        for(int i = 0; i < nums.length; i++){
            //若最小的数大于0，直接返回
            if(nums[i] > 0){
                return res;
            }
            //在求和前去重
            //若i指向的数与上一个数相同
            //最后得到的组合与上一个组合一致，跳过该数
            if(i > 0 && nums[i] == nums[i-1]){
                continue;
            }

            //定义左右指针
            int left = i+1;
            int right = nums.length-1;
            //定义三数之和
            int sum = 0;
            //开始循环
            while(left < right){
                sum = nums[i] + nums[left] + nums[right];
                //大于0，右指针向左移动
                if(sum > 0){
                    right--;
                    //去重
                    while(left < right && nums[right] == nums[right+1]){
                        right--;
                    }
                }else if(sum < 0){//小于0，则左指针向右移动
                    left++;
                    //去重
                    while(left < right && nums[left] == nums[left-1]){
                        left++;
                    }
                }else{//等于0则存储三个值
                    res.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    //去重
                    while(left < right && nums[right] == nums[right-1]){
                        right--;
                    }
                    while(left < right && nums[left] == nums[left+1]){
                        left++;
                    }
                    //开始下一轮循环
                    left++;
                    right--;
                }
            }
        }
        return res;
    }
}

18 四数之和

• 同一个数组找出四个元素之和为目标值，但是四个元素不能重复，使用双指针法，同上。
• 首先将数组升序排序，使用两层循环i，j遍历数组，j指向i+1；左指针指向j+1，右指针指向数组最右端，若i，j与左右指针指向数之和大于0，则右指针向左移动；若小于0，则左指针向右移动；若等于0则存储三个值，注意不管大小等于都需要进行去重，直到左右指针相遇进入下一轮循环。
• 注意：排序后不再判断i指向的数是否大于0，因为目标值为不确定。在求和前去重，同上。

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        //数组升序排序
        Arrays.sort(nums);
        //定义List存储结果
        List<List<Integer>> res = new ArrayList<>();
        //使用i，j遍历数组
        for(int i = 0; i < nums.length; i++){
            //去重
            if(i > 0 && nums[i] == nums[i-1]){
                continue;
            }
            //j指向i+1
            for(int j = i+1; j < nums.length; j++){
                //去重
                if(j > i+1 && nums[j] == nums[j-1]){
                    continue;
                }
                //定义左右指针
                int left = j + 1;
                int right = nums.length - 1;
                //开始循环求和
                int sum = 0;
                while(left < right){
                    //四数和大于目标值，防止溢出，右指针左移
                    sum = nums[i] + nums[j] + nums[left] + nums[right];
                    if(sum > target){
                        right--;
                        //去重
                        while(left < right && nums[right] == nums[right+1]) right--;
                    }else if(sum < target){//和小于目标值，左指针右移
                        left++;
                        while(left < right && nums[left] == nums[left-1]) left++;
                    }else{//和等于目标值
                        res.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                        //去重
                        while(left < right && nums[right] == nums[right-1]) right--;
                        while(left < right && nums[left] == nums[left+1]) left++;
                        //开始下一轮循环
                        right--;
                        left++;
                    }
                }
            }
        }
        return res;
    }
}