【双指针+简化去重操作】【int运算溢出】Leetcode 18 四数之和

----------------------题目链接----------------------
----------------------解析链接----------------------

解法1 仍然用双指针法 就是在三数求和的基础上扩展一个外层循环

新建一个嵌套列表：List<List<Integer>> result = new List<>();
初始化一个ArrayList并直接赋值：ArrayList<Integer> result = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
向列表中添加元素：result.add()
向ArrayList中添加：result.add (Arrays.asList(1, 2, 3, 4));

操作流程

1. nums数组进行排序！！！
2. nums[i] 从头到倒数第四个遍历数组，nums[j] 从i的下一个开始到倒数第三个遍历数组，
   nums[left]是nums[i]的下一个元素，nums[right]最初指向数组的最后一个元素
3. 考察nums[i] + nums[j] + nums[left] + nums[right]的情况。如果和大于0，则right–，如果和小于0，则left++，等于0则添加结果

去重操作（不可以包含重复的四元组）

• 对 i 进行去重：如果 i>0 , nums[i] == nums[i-1] ， continue
• 对 j 进行去重：如果 j>1 , j != i+1 , nums[j] == nums[j-1] ， continue
• 对 left 进行去重：如果nums[left] == nums[left+1]。left++
• 对 right 进行去重：如果nums[right] == nums[right - 1]。right–

溢出问题
在Java中，int类型的大小是固定的，它是一个32位的整数类型。
因此，它的最大值是2^31 - 1，即2147483647，最小值是-2^31，即-2147483648。
如果你尝试存储超过这个范围的值，就会发生溢出。
(long)转化

时间复杂度O(N^3)
空间复杂度O(1)

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        //仍然用双指针法 就是在三数求和的基础上扩展一个外层循环

        List<List<Integer>> result = new ArrayList<>();

        // 从小到大 排序
        Arrays.sort(nums);

        // nums[i] nums[j]外层双循环 nums[left] nums[right]双指针遍历
        for(int i = 0; i < nums.length-3; i++){
  
            // 去重i
            if(i>0 && nums[i] == nums[i-1]) continue;

            for(int j = i+1; j < nums.length-2; j++){
                int left = j+1;
                int right = nums.length-1;

                // 去重j
                if(j>1 && j != i+1 && nums[j] == nums[j-1]) continue;

                while(left < right){
                    if((long)nums[i]+nums[j]+nums[left]+nums[right] > target){ //防止溢出
                        right--;
                    }
                    else if((long)nums[i]+nums[j]+nums[left]+nums[right] < target){//防止溢出
                        left++;
                    }
                    else{
                        result.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                        // 去重left 
                        while(left < right && nums[left] == nums[left+1]){
                            left++;
                        }
                        // 去重right
                        while(left < right && nums[right] == nums[right - 1]){
                            right--;
                        }
                        left++;
                        right--;
                    }
                }
            }
        }
        return result;

    }
}