Leetcode 之两数之和 与 三数之和

1. 两数之和

求解两数之和是 LeetCode 上的第一道题。
题目中有一个值得注意的地方：“数组中同一个元素在答案中不能重复出现”。
本文试着用最直接的方法求解，再逐步优化求解过程。
知识点：map、unordered_map 的用法（find 和 count 以及 insert），去除重复解。

1.1 暴力法

拿到题目，第一反应就是通过两次遍历数组，实现暴力求解。
遍历整个数组，尝试为每个数组元素 nums[i] 找到一个求和为 target 的数组元素，然后返回数组元素的对应下标。
由于是双重循环，因此算法的时间复杂度为 O(n²)。
注意 ：题目要求不可以有重复的数组元素，所以第二次循环需从 nums[i] 后的元素开始，即 for(int j = i + 1; j < nums.size(); j++)

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
    
    	# i < nums.size() - 1 是考虑到nums 数组中最后一个元素之后再无元素与之匹配
    	# 最后一个元素只可能和前面的元素完成了匹配（两元素和为 target）
    	# 当然也可以写作 i < nums.size()
    	
        for(int i = 0; i < nums.size() - 1; i++)
        {
            for(int j = i + 1; j < nums.size(); j++)
            {
                if(nums[j] == target - nums[i])
                    return {i,j};
            }
        }
        # 如果无法找到与数组元素和为 target 的元素，则返回下标 {-1, -1}
        return {-1,-1};
    }
};

1.2 hash表

上面的算法时间复杂度较高，有没有什么办法可以优化一下呢?
用 nums[i] 表示数组元素，在数组中查找 target - nums[i] 是一件时间复杂度较高的事情。
那么有没有一种数据结构查找操作的时间复杂度较低呢？
有，hash 表查找的时间复杂度为 O(1)。

创建一个hash表 table，key 为 nums[i]，value 为 元素下标 i 。
在数组中查找 target - nums[i] ，可以写作 table.find(target - nums[i])，如果找到了与 nums[i] 匹配的元素， 则返回下标 {table[target - nums[i]], i}。否则，将元素 nums[i], i 插入hash表中，继续查找。
现在还有一个问题：如何确保 nums[i] 不与自身进行匹配呢？

先进行匹配（找和为target的元素），再向 hash 表插入元素。
这里以下面的数据为例进行说明

输入：nums = [3,3], target = 6
输出：[0,1]

若 hash 表里已存在 3，当数组元素为 3 时，那么可以在 hash 表中找到 target = 6 的元素。两个 3 具有不同的索引值。满足题目要求的答案中不可以有重复的数组元素。

法1：用 find 函数实现

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> table;
        for(int i = 0; i < nums.size(); i++)
        {
            if(table.find(target - nums[i]) != table.end())
            {
                return {table[target - nums[i]], i};
            }
            table[nums[i]] = i;
        }
        return {};

    }
};

法2：用 count 函数实现，大于0则说明存在与 nums[i] 求和为 target 的数组元素。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> table;
        for(int i = 0; i < nums.size(); i++)
        {
            if(table.count(target - nums[i]) > 0)
            {
                return {table[target - nums[i]], i};
            }
            table[nums[i]] = i;
        }
        return {};

    }
};

法3：两次hash
首先将数组所有元素放入hash表中，然后查找和为 target 的数组元素，并判断是否为数组元素本身 if(it != res.end() && res[target - nums[i]] != i)。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        map<int,int> res;
        for(int i = 0; i < nums.size(); i++)
        {
            res.insert(make_pair(nums[i],i));
        }
        for(int i = 0; i < nums.size(); i++)
        {
            auto it = res.find(target - nums[i]);
            if(it != res.end() && res[target - nums[i]] != i)
            {
                return {it->second, i};
            }
        }
        return {};
    }
};

2. 三数之和

前面解决了两数之和的问题，现在我们来看三数之和。
这个问题直接遍历（暴力求解）是不行了。因此尝试用一个常用方法来解题：双指针法。
知识点：双指针法，vector 的使用（sort 排序，元素插入）。

2.1 双指针法

应用双指针法前，先对数组进行排序。
然后考虑特殊情况，
数组元素个数小于 3 个，则说明没有满足题目要求的三元组，因此返回一个空数组 {}。
数组元素值大于0时，即后面所有元素都大于0，不可能有没有满足题目要求的三元组，因此返回一个空数组 {}。

注意： 此处的空数组不可以直接写作 {}，因为 nums[i] > 0 只是说明当前数组元素无法构成三元组，不代表所有元素都无法构成三元组，即 返回值为 {}。因此此处应该写成 return result。 result 中记录了之前的数组元素构成的三元组。

考虑普遍情况，对数组元素进行遍历
i 是当前数组元素， left 和 right 为数组的左右指针。

int left = i + 1;
int right = nums.size() - 1;

当 nums[i] + nums[left] + nums[right] = 0 时，i 、left 和 right 都在合适的位置。
当 nums[i] + nums[left] + nums[right] > 0 时， right 的值过大，因此 right--。
当 nums[i] + nums[left] + nums[right] < 0 时， left 的值过小，因此 left++。

此时，还需考虑去重的问题。因为题目要求不可以包括重复的三元组。

首先考虑数组元素的去重
这里需要注意的是，要写成

if(i > 0 && nums[i] == nums[i - 1])
    continue;

即 前面已经出现过的数组元素，不再出现在三元组中。
而不是

// 错误去重方法，将会漏掉-1,-1,2 这种情况
/*
if (nums[i] == nums[i + 1]) {
    continue;
}

然后考虑 nums[i] + nums[left] + nums[right] = 0 时的去重，
right 向左搜索，判断nums[right] == nums[right - 1]
left 向右搜索，判断 nums[left] == nums[left + 1]
当 left = right 时，i , nums[left] , nums[right] 只剩两个元素，无法构成三元组

while(left < right && nums[right] == nums[right - 1])  right--;
while(left < right && nums[left] == nums[left + 1]) left++;
// 找到答案时，双指针同时收缩
right--;
left++;

下面给出完整代码

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        // vector<int> temp;
        vector<vector<int>> result;
        if(nums.size() < 3) return result;
        sort(nums.begin(), nums.end());
        for(int i = 0; i < nums.size(); i++)
        {
            
            if(nums[i] > 0) return result;
            if(i > 0 && nums[i] == nums[i - 1])
                continue;
            int left = i + 1;
            int right = nums.size() - 1;
            while(left < right)
            {
                if(nums[i] + nums[left] + nums[right] > 0)
                {
                    right--;
                }
                else if(nums[i] + nums[left] + nums[right] < 0)
                {
                    left++;
                }
                else
                {
                    result.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    
                    while(left < right && nums[right] == nums[right - 1])  right--;
                    while(left < right && nums[left] == nums[left + 1]) left++;
                    right--;
                    left++;
                    

                }
            }
        }
        return result;
    }

};

参考链接

1. 「代码随想录」带你搞定哈希表！15. 三数之和:【哈希法】【双指针法】详解
2. labuladong的算法小抄