LeetCode 15. 三数之和

今天来说说LeetCode上的三数之和，这道题如果不考虑时间复杂度的话，可以暴力的直接用三个for循环来解决，当然了要注意去重。但是用三个for循环效率非常差并且可能会超时，所以这里提供另一种解法：双指针。

双指针：维护两个索引i，j，i一般是0，j一般是数组的长度-1，根据需求让i向右移动或者让j向左移动，结束条件为：i >= j。

下面先给出暴力的解法，注意去重。

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

注意：答案中不可以包含重复的三元组。

例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，

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

 这里还需要注意一点的就是，需要先对数组进行排序，这样去重操作才不会出错，并且可以对三层for循环进行优化，但是最后还是会超时，所以建议使用双指针解法。排序我没有调用java的Arrays.sort(nums)方法进行排序，而是手写了一个快排，下面一并贴出来。

//快排
private void quicksort(int[] nums,int left,int right){
        //递归结束条件
        if(left >= right || nums == null)
            return;
        //找一个基准数
        int key = nums[left];
        int l = left,r = right;
        while(l < r){
            //在数组右边找比基准数小的数
            while(l < r && nums[r] >= key)
                r--;
            //在数组左边找比基准数大的数
            while(l < r && nums[l] <= key)
                l++;
            //如果满足条件则交换两个的值
            if(l < r)
                nums[l] = nums[l] + nums[r] - (nums[r] = nums[l]);
        }
        nums[left] = nums[l];
        nums[l] = key;
        //递归排序左边的数组
        quicksort(nums,left,l - 1);
        //递归排序右边的数组
        quicksort(nums,l + 1,right);
    }

public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new LinkedList<>();
        quicksort(nums,0,nums.length - 1);
        
        for(int i = 0;i < nums.length;i++){
            //如果nums[i] > 0 那么因为是排序的 所以加上后面两个数的和一定大于0 那么可以直接结束循环
            if(nums[i] > 0)
                break;
            //去重
            if(i > 0 && nums[i] == nums[i - 1])
                continue;
            for(int j = i + 1;j < nums.length;j++){
                //同上 不过判断条件改为 nums[i] + nums[j] > 0
                if(nums[i] + nums[j] > 0)
                    break;
                //去重
                if(j > i + 1 && nums[j] == nums[j - 1])
                    continue;
                for(int t = j + 1;t < nums.length;t++){
                    //同上如果三数之和大于0直接结束循环
                    if(nums[i] + nums[j] + nums[t] > 0)
                        break;
                    //去重
                    if(t > j + 1 && nums[t] == nums[t - 1])
                        continue;
                    if(nums[i] + nums[j] + nums[t] == 0)
                        res.add(Arrays.asList(nums[i],nums[j],nums[t]));
                }
            }
        }
        
        return res;
    }

 下面给出双指针的解法，同样是用java代码实现的。

public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new LinkedList<>();
        //Arrays.sort(nums);
        quicksort(nums,0,nums.length - 1);
        
        for(int i = 0;i < nums.length;i++){
            //因为是有序数组 当nums[0] > 0 时，后面的两个数也大于0 那么三数之和一定大于0 直接退出循环
            if(nums[i] > 0)
                break;
            //去重
            if(i > 0 && nums[i] == nums[i - 1])
                continue;
            //维护两个索引 l向右走 r向左走
            int l = i + 1,r = nums.length - 1;
            while(l < r){
                //三数之和
                int sum = nums[i] + nums[l] + nums[r];
                if(sum == 0){
                    //如果三数之和刚好为0的话 就加入到结果集中
                    res.add(Arrays.asList(nums[i],nums[l],nums[r]));
                    //去重
                    while(l < r && nums[l] == nums[l + 1])
                        l++;
                    //去重
                    while(l < r && nums[r] == nums[r - 1])
                        r--;
                    //l向右移动
                    l++;
                    //r向左移动
                    r--;
                }
                //如果当前三数之和小于0 那么需要找到一个更大的数来替换其中的一个数 在这里我们选                    
                //择让l向右移 因为数组是有序的，所以这样 nums[l]就变大了
                else if(sum < 0)
                    l++;
                //如果当前三数之和大于0 那么需要找到一个更小的数来替换其中的一个数 在这里我们选 
                //择让r向左移 因为数组是有序的，所以这样 nums[r]就变小了
                else
                    r--;
            }
        }
        return res;
    }