Leetcode15. 三数之和——双指针法

首先尝试用算法课上刚学的threeSumBinarySearch()求解。在确定了第一个数和第二个数之后，第三个数便为前两者之和的负数，通过二分查找来找第三个数。即两层循环+一次二分查找。该算法时间复杂度为N^2lgN。

尝试了半个晚上，这个方法宣告失败。后来在网上查到原因，二分查找只有数组不含有相同元素才能使用这种解法,否则二分查找的结果会出错。附上错误代码，以后有能力了回头看看有没有可能写出来。

class Solution {
public:

    int binarySearch(vector<int>& nums, int target, int j){
        int left = j;
        int right = nums.size() - 1;

        while(left <= right){
            int mid = left + (right - left) / 2;
            if(nums[mid] == target) {
                return mid;
            }else if(nums[mid] > target){
                right = mid - 1;
            }else{
                left = mid + 1;
            }
        }
        return -1;
    }

    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        if(nums.size() == 0) return result;

        sort(nums.begin(), nums.end());

        for(int i = 0; i < nums.size(); i++){
            if(i > 0 && nums[i] == nums[i - 1]) continue;
            for(int j = i + 1; j < nums.size(); j++){
                int target = - (nums[i] + nums[j]);
                int index = binarySearch(nums, target, j + 1);
                if(index != -1) result.push_back(vector<int>{nums[i], nums[j], nums[index]});
            }
        }
        return result;
    }
};

双指针法

在两数和的基础上，用双指针的思想写三数和是很容易的。这道题的难点在于去重。1. 对于元组（a, b, c)，使得a <= b <= c可以使得元组不会有不同的排列顺序。2. 同时每一个位置的数也不能重复。

代码可以优化改进的地方：

1. 判断输入数组元素个数小于3个，直接返回
2. 依次遍历排序后的数组时，判断当前元素是否为正，是则结束循环，因为后续的数字也都为正，不会出现三数之和为0的情况

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        
        if(nums.size() < 3) return result;//数组为空或元素个数小于3直接返回

        sort(nums.begin(), nums.end());

        for(int i = 0; i < nums.size(); i++){
        	if(nums[i] > 0) return result; //最小数大于0相加不会得0
            //对i去重，此处注意可能导致溢出的条件需要放在前面
            if(i > 0 && nums[i] == nums[i - 1]) continue;

            int n = 0 - nums[i];
            int left = i + 1;
            int right = nums.size() - 1;
            while(left < right){
                int sum = nums[left] + nums[right];
                if(sum > n){
                    right --;
                }else if(sum < n){
                    left ++;
                }else{
                    result.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    
                    //对左右边界去重,此处注意可能导致溢出的条件需要放在前面
                    while(left < right && nums[left] == nums[left + 1]) left ++;
                    while(left < right && nums[right] == nums[right - 1]) right --;

                    //找到答案，双指针同时收缩
                    right --;
                    left ++;
                }
            }
        }

        return result;
    }
};

学习到的小语法点：

• 返回值为vector<vector>类型的处理方法：可声明vector<vector> result，然后result.push_back(vector{nums[i], nums[j], nums[index]})