LeetCode - 001 两数字和

给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。

你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

方法一：两次遍历
比较高效的索引方案是哈希表：哈希表通过以空间换取速度的方式，将查找时间从 O(n) 降低到 O(1) 。哈希表它支持以 近似 恒定的时间进行快速查找。我用“近似”来描述，是因为一旦出现冲突，查找用时可能会退化到 O(n) 。但只要仔细地挑选哈希函数，在哈希表中进行查找的用时应当被摊销为 O(1) 。我们可以用一个简单使用两次迭代来解决这道题目：在第一次迭代中，我们将每个元素的值和它的索引添加到表中；然后在第二次迭代中，我们将检查每个元素所对应的目标元素 (target−nums[i]) 是否存在于表中。注意，该目标元素不能是 nums[i] 本身！

答案：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> twoSum;
        map<int, int> tmp_map;
        for(int i = 0 ;i < nums.size();i++)
        {
            tmp_map[nums[i]] = i;	//key为nums的值，value为nums值的索引
        }
        for(int i = 0 ;i < nums.size();i++)
        {
            int another = target - nums[i];
            if(tmp_map.find(another)!=tmp_map.end() && tmp_map[another]!=i)
            {
                twoSum.push_back(i);
                twoSum.push_back(tmp_map[another]);
                break;       
            }
        }
        return twoSum;
        
    }
};

一样的思路，代码可以改写为

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> res;
        std::map<int, int> mp;
        if(nums.empty()){
            return res;
        }
        int n = nums.size();
        for(int i = 0; i < n; i++) {
            if(mp.count(target - nums[i]) > 0) {
                res.emplace_back(i);
                res.emplace_back(mp[target - nums[i]]);
                break;
            }
            mp[nums[i]] = i;
        }
        return res;
    }
};

• 时间复杂度：O(n)，我们把包含有 n 个元素的列表遍历两次。由于哈希表将查找时间缩短到 O(1) ，所以时间复杂度为 O(n) 。

• 空间复杂度：O(n)，所需的额外空间取决于哈希表中存储的元素数量，该表中存储了 n 个元素。

方法二：一次遍历
其实优化策略就是把两次遍历合为一次：在进行迭代并将元素插入到表中的同时，我们还会回过头来检查表中是否已经存在当前元素所对应的目标元素。如果它存在，那我们已经找到了对应解，并立即将其返回。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> twoSum;
        map<int, int> tmp_map; //key为nums的值，value为nums值的索引
        for(int i = 0 ;i < nums.size();i++)
        {
            int another = target - nums[i];
            if(tmp_map.find(another)!=tmp_map.end())
            {
                twoSum.push_back(tmp_map[another]);
                twoSum.push_back(i);
            }
            tmp_map[nums[i]] = i;
        }
        return twoSum;
    }
};

方法三：暴力解法
这个直接遍历所有元素就好，和上面的方法二接近，代码简单易懂，无需赘述，直接看代码就好。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> res;
        if(nums.empty()){
            return res;
        }
        int n = nums.size();
        for(int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if(nums[i] + nums[j] == target) {
                    res.emplace_back(i);
                    res.emplace_back(j);
                    break;
                }
            }
        }
        return res;
    }
};

最简洁版本代码

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