绪论

曾经有一位名人窝镃基硕得说过，“我爱学习，学习爱我，学习使人快乐”。马上就要找工作，就要毕业了，本渣心中甚是惶恐。在得知如今挨踢精英男的高薪工资以及互联网的迅猛势头后，不免也有些向往，退一万步讲，就算是作为一个工科男，代码敲得好也算是必备技能了，基于此，便抱起一本C++啃了起来。

至于为什么没选Java，首先，C++以前学过，有点基础，其次，万一最后是去当了个自动化工程师，C/C++还能派上用场，最后，本渣相信能学好C++,其他语言也不是问题。~~还有一点就是Java要看的东西太多，本人有点懒。~~ 看了良久之后，深感光说不练假把式，不如把leetcod刷起来。说干就干，还能更个博客。

在这里插入图片描述

两数之和(2019.02.26)

题目描述

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

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

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

我的解法

嗯？从数组中取两个数，共有组合数 $\binom 2 n$ 种取法，用两层循环取遍组合数，满足要求就返回值，这应该是最直接的想法了吧？然后我就这么做了：

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

结果。。。

在这里插入图片描述

扫描二维码关注公众号，回复： 5390473 查看本文章

我就不服了，难道官方还有更好的更简单的方法吗？

官方解法

方法一：暴力法。

暴力法很简单。遍历每个元素x，并查找是否存在一个值与 target−x 相等的目标元素。

复杂度分析：

时间复杂度： $O(n^{2})$

对于每个元素，我们试图通过遍历数组的其余部分来寻找它所对应的目标元素，这将耗费 $O(n)$ 的时间。因此时间复杂度为 $O(n^{2})$ 。
空间复杂度： $O(1)$ 。

emmm…,这跟我的解法一样嘛。的确还有优化的空间。

方法二：两遍哈希表

为了对运行时间复杂度进行优化，我们需要一种更有效的方法来检查数组中是否存在目标元素。如果存在，我们需要找出它的索引。保持数组中的每个元素与其索引相互对应的最好方法是什么？哈希表。

通过以空间换取速度的方式，我们可以将查找时间从 $O(n)$ 降低到 $O(1)$ 。哈希表正是为此目的而构建的，它支持以近似恒定的时间进行快速查找。我用“近似”来描述，是因为一旦出现冲突，查找用时可能会退化到 $O(n)$ 。但只要你仔细地挑选哈希函数，在哈希表中进行查找的用时应当被摊销为 $O(1)$ 。

一个简单的实现使用了两次迭代。在第一次迭代中，我们将每个元素的值和它的索引添加到表中。然后，在第二次迭代中，我们将检查每个元素所对应的目标元素(target−nums[i])是否存在于表中。注意，该目标元素不能是 nums[i]本身！

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

复杂度分析：

时间复杂度： $O(n)$

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

所需的额外空间取决于哈希表中存储的元素数量，该表中存储了 $n$ 个元素。
方法三：一遍哈希表

事实证明，我们可以一次完成。在进行迭代并将元素插入到表中的同时，我们还会回过头来检查表中是否已经存在当前元素所对应的目标元素。如果它存在，那我们已经找到了对应解，并立即将其返回。

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

复杂度分析：

时间复杂度： $O(n)$ ，

我们只遍历了包含有 $n$ 个元素的列表一次。在表中进行的每次查找只花费 $O(1)$ 的时间。
空间复杂度： $O(n)$

所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储 $n$ 个元素。

一句话总结

在遇到数组问题时，使用哈希表一般会有奇效。

我的leetcode之旅--万事开头难

绪论

两数之和(2019.02.26)

题目描述

我的解法

官方解法

一句话总结

猜你喜欢