LeetCode 18. 四数之和

18. 四数之和

给定一个包含 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. 小白的代码(可通过，效率不高)

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
       /*创建返回的list*/ 
     List<List<Integer>> res = new ArrayList<>();
        /*将数组按从小到大排序*/
        /*当数组为null或元素小于4个时，直接返回*/
        if(nums==null||nums.length<4){
            return res;
        }
		Arrays.sort(nums);
        /*第一层循环i 四个数中的第一个数 范围[0,nums.length-3) 左开右闭*/
		for (int i = 0; i < nums.length - 3; i++) {
            /*该判断是为了取出i>0以后 第一个数会重复的情况，如果重复继续执行i++*/
			if (i > 0 && nums[i] == nums[i - 1])
				continue;
            /*第二层循环j 四个数中的第二个数 范围[1,nums.length-2) 左开右闭*/
			for (int j = i + 1; j < nums.length - 2; j++) {
            /*该判断是为了取出j>i+1以后 第二个数会重复的情况，如果重复继续执行j++*/
				if (j > (i + 1) && nums[j] == nums[j - 1])
					continue;
                /*left 四个数中的第三个数 范围[2,nums.length-1)*/ 
				int left = j + 1;
                /*right 四个数中的最后一个数 从末尾开始往回遍历*/
				int right = nums.length - 1;
                /*内层循环 移动left与right来寻找符合条件的left和right*/
				while (left < right) {
                    /*创建一个临时变量 lists用于存放符合条件的数据*/
					List<Integer> lists = new ArrayList<>();
                    /*满足条件的情况  将数据添加到list中，并移动left和right*/
		    if (nums[i] + nums[j] + nums[left] + nums[right] == target) {
                  /*添加语句可以换成：  res.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));*/
						lists.add(nums[i]);
						lists.add(nums[j]);
						lists.add(nums[left]);
						lists.add(nums[right]);
						left++;
						/*该循环是为了去除第三个数即left会重复的情况*/
			while (left < right && nums[left] == nums[left - 1]) {
							left++;
						}

						right--;
           	/*该循环是为了去除第四个数即right会重复的情况*/
			while (left < right && nums[right] == nums[right + 1]) {
							right--;
						}
                
			} 
          /*不满足条件的情况 
          累加和>target 说明累加和较大 应将大数变小 即right右移
          累加和<target 说明累加和较小 应将小数变大 即left左移*/ 
          else if (nums[i] + nums[j] + nums[left] + nums[right] > target) {
						right--;
					} else {
						left++;
					}
                    //lists不为空时，就将其加入到res
					if (lists.size() > 0) {
						res.add(lists);
					}
				}
			}

		}
		return res;
   }
}

2. 官方代码

public List<List<Integer>> fourSum(int[] nums,int target){
        /*定义一个返回值*/
        List<List<Integer>> result=new ArrayList<>();
        /*当数组为null或元素小于4个时，直接返回*/
        if(nums==null||nums.length<4){
            return result;
        }  
        /*对数组进行从小到大排序*/
        Arrays.sort(nums);
        /*数组长度*/
        int length=nums.length;
        /*定义4个指针k，i，j，h  k从0开始遍历，i从k+1开始遍历，留下j和h，j指向i+1，h指向数组最大值*/
        for(int k=0;k<length-3;k++){
            /*当k的值与前面的值相等时忽略*/
            if(k>0&&nums[k]==nums[k-1]){
                continue;
            }
            /*获取当前最小值，如果最小值比目标值大，说明后面越来越大的值根本没戏*/
            int min1=nums[k]+nums[k+1]+nums[k+2]+nums[k+3];
            if(min1>target){
                break;
            }
            /*获取当前最大值，如果最大值比目标值小，说明后面越来越小的值根本没戏，忽略*/
            int max1=nums[k]+nums[length-1]+nums[length-2]+nums[length-3];
            if(max1<target){
                continue;
            }
            /*第二层循环i，初始值指向k+1*/
            for(int i=k+1;i<length-2;i++){
                /*当i的值与前面的值相等时忽略*/
                if(i>k+1&&nums[i]==nums[i-1]){
                    continue;
                }
                /*定义指针j指向i+1*/
                int j=i+1;
                /*定义指针h指向数组末尾*/
                int h=length-1;
                /*获取当前最小值，如果最小值比目标值大，说明后面越来越大的值根本没戏*/
                int min=nums[k]+nums[i]+nums[j]+nums[j+1];
                if(min>target){
                    break;
                }
                /*获取当前最大值，如果最大值比目标值小，说明后面越来越小的值根本没戏，忽略*/
                int max=nums[k]+nums[i]+nums[h]+nums[h-1];
                if(max<target){
                    continue;
                }
                /*开始j指针和h指针的表演，计算当前和，如果等于目标值，j++并去重，h--并去重，当当前和大于目标值时h--，当当前和小于目标值时j++*/
                while (j<h){
                    int curr=nums[k]+nums[i]+nums[j]+nums[h];
                    if(curr==target){
                        result.add(Arrays.asList(nums[k],nums[i],nums[j],nums[h]));
                        j++;
                        while(j<h&&nums[j]==nums[j-1]){
                            j++;
                        }
                        h--;
                        while(j<h&&i<h&&nums[h]==nums[h+1]){
                            h--;
                        }
                    }else if(curr>target){
                        h--;
                    }else {
                       j++;
                    }
                }
            }
        }
        return result;
    }