LeetCode刷题——三数之和

LeetCode15–三数之和

题目

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。
给定数组 nums = [-1, 0, 1, 2, -1, -4]，

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

思路

最朴素的想法就是三重循环暴力破解，但这题中暴力破解是不可行的，因为题目要求不能返回有重复的答案，这是暴力循环做不到的（当然，你暴力完强行遍历结果进行去重当我没说）
因此我们首先要解决去重问题，这点比较好办，先对数组进行排序，然后在遍历的时候查看当前元素的前一个元素，如果二者相同，则跳过当前循环

Arrays.sort(nums)
for (int i = 0; i < len-2; i++){
	if (nums[i] == nums[i-1])
		continue;
	for (int j = 1; j < len-1; j++){
		if (nums[j] == nums[j-1])
			continue;
		for (int k = 2; k < len; k++){
			if (nums[k] == nums[k-1])
				continue;
			if (nums[i] + nums[j] + nums[k] == 0)
				加入结果
		}
	}
}

看似解决了。但其实时间复杂度还是在$O(n^3)$，我们是否还能继续优化呢？

双指针优化

这里就要提到我们的双指针了，即通过两个指针将原本的二层和三层循环变成并行的一层循环。

对于下面这个数组
[-4, -1 ,-1, 0, 1, 2]
 ^
 f

我们分别记三个数为f、s、t，我们不难发现在一个排好序的数组中，如果固定f，只看s、t，对于f + s + t有大于0， 小于0， 等于0三种情况：

1. $f+s+t>0$ 时，需要减小三者和的值，因此需要左移t，使其减小
2. $f+s+t<0$ 时，需要增大三者和的值，因此需要右移t，使其增加
3. $f+s+t=0$ 时，此时即为一种结果，我们需要将数组加入结果集中，并且移动指针，这里理论上移动s或者t都是可以的

当s和t处于同一位置时，说明对于当前的f，所有的可能结果已经遍历结束，即可移动f，开始下一轮搜索。这样我们就可以把$O(n^3)$的复杂度优化到$O(N^2)$

代码实现

Java中提供数组排序的函数，但这里本着练手的目的，就手写了一下归并排序，但是效率貌似没有Java给的函数高，有时间再研究研究！

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> continar = new ArrayList<List<Integer>>();
        int len = nums.length;
        //不够长的直接返回空
        if (len <= 2)
            return continar;
        //先排序
        merge_sort(nums, 0, len-1);
        //使用双指针优化内层两重循环
        for (int i = 0; i < len-2; i++){
            //去重
            if (i > 0 && nums[i] == nums[i-1])
                continue;
            //双指针
            int second = i + 1;
            int third = len - 1;
            int target = -nums[i];
            while (second < third){
                //去重
                if (second > i+1 && nums[second] == nums[second-1]){
                    second ++;
                    continue;
                }
                if (third < len-1 && nums[third] == nums[third+1]){
                    third --;
                    continue;
                }
                //判断
                int res = nums[second] + nums[third];
                //如果三者和为0，则添加结果，并且移动指针，这里选择右移s
                if (res == target){
                    List<Integer> tuple = new ArrayList<Integer>();
                    tuple.add(nums[i]);
                    tuple.add(nums[second]);
                    tuple.add(nums[third]);
                    //添加到结果
                    continar.add(tuple);
                    second ++;
                }
                //如果大于0，需要减小和，因此左移t
                else if (res > target){
                    third --;
                }
                //如果大于0，需要增大和，因此右移t
                else{
                    second ++;
                }
            }
        }
     	//返回结果
        return continar;
    }
    //实现归并排序
    void merge(int[] array, int low, int mid, int high){
        //申请临时存储空间
        int[] temp = new int[high-low+1];
        //创建左右部分指针
        int left_low = low;
        int left_high = mid;
        int right_low = mid + 1;
        int right_high = high;
        //循环比较
        int i = 0;
        for (i = 0; left_low <= left_high && right_low <= right_high; i++){
            if (array[left_low] < array[right_low])
                temp[i] = array[left_low++];
            else
                temp[i] = array[right_low++];
        }
        //处理左右不一样长的情况
        if (left_low <= left_high){
            for (int j = left_low; j <= left_high; j++)
                temp[i++] = array[j];
        }
        if (right_low <= right_high){
            for (int j = right_low; j <= right_high; j++)
                temp[i++] = array[j];
        }
        //把排序完成的值赋给原来的数组
        for (int j = 0; j < high-low+1; j++){
            //System.out.println(temp[j]);
            array[low+j] = temp[j];
        }
        //System.out.println("结束\n");
    }
    void merge_sort(int array[], int low, int high){
    	//递归调用merge_sort函数
        int mid = 0;
        if (low < high){
            mid = (low + high) / 2;
            merge_sort(array, low, mid);
            merge_sort(array, mid+1, high);
            merge(array, low, mid, high);
        }
    }
}

不了解归并排序的朋友可以看这里

复杂度分析

时间复杂度：$O(n^2)$ 双重循环
空间复杂度：$O(n\ast logn)$ 归并排序需要的额外空间。