力扣题库--两数之和

题目描述

题目来自力扣，地址： 两数之和.
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

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

示例:

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

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

题目中已说明只会对应一个答案，所以先不考虑没有答案和多个答案的场景。

暴力法

暴力法就是对数组进行遍历，查看每个元素x是否存在另一个值等于target-x
复杂度分析：
时间复杂度：O(n²)， 对于每个元素，我们试图通过遍历数组的其余部分来寻找它所对应的目标元素，这将耗费 O(n) 的时间。因此时间复杂度为 O(n²)
空间复杂度：O(1)。

代码1：

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

结果：

性能很低啊，击败0.98%的用户，那我们对暴力法我们做一个小小的优化，性能就可以提升很多，就是尽量减少其中的加减运算。
代码2：

class Solution {
    public: 
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> result(2);
        int num(nums.size());
        int num2(num - 1);
        int tmp(0);
        
        for(int i = 0; i < num2; i++){
            tmp = target - nums[i];
            for(int j = i+1;j < num; j++){
                if (nums[j] == tmp){
                    result[0] = i;
                    result[1] = j;
                    return result;
                }
            }
        }
        return result;
    }
};

结果

暴力法的时间复杂度是O(n²)，再怎么优化也难以缩短他的执行时间了，所以要找时间复杂度更小的方法。

排序法

将数组先排个序，然后从两头开始向中间查找最合适的，找到合适的跳出就可以了。
复杂度分析：
时间复杂度：O(n)， 我们把包含有 n 个元素的列表遍历两次。
空间复杂度：O(n)， 所需的额外空间取决于哈希表中存储的元素数量，该表中存储了 n 个元素。
代码3

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int>new_nums(nums);
        int a(0);
        int b(0);
        int sum(0);
        
        sort(new_nums.begin(),new_nums.end());/*对数组排序了*/
        
        for(int i = 0, j = new_nums.size() - 1; i < j;)
        {
            sum = new_nums[i] + new_nums[j];
            if(sum == target)  /*符合结果*/
            {
                a = new_nums[i];
                b = new_nums[j];
                break;
            }
            if(sum < target)           //左边数小了
            {
                i++;
            }
            else      //右边数大了
            {
                j--;
            }
        }
        
        vector<int> retVec;
        for(int i = 0; retVec.size() < 2 && i < nums.size();i++)/*寻找原来的位置*/
        {
            if(a == nums[i] || b == nums[i])
            {
                retVec.push_back(i);
            }
        }
        return retVec;
    }
};

结果

哈希法

使用unordered_map，需要使用C++11以上。
unordered_map内部实现了哈希表，因此其查找速度非常的快，缺点是创建unordered_map比较慢，耗内存。
使用count，返回的是被查找元素的个数。如果有，返回1；否则，返回0。注意，map中不存在相同元素，所以返回值只能是1或0。

哈希法用空间换时间吧。
在进行迭代并将元素插入到表中的同时，我们还会回过头来检查表中是否已经存在当前元素所对应的目标元素。如果它存在，那我们已经找到了对应解，并立即将其返回。

复杂度分析：
时间复杂度：O(n)， 我们只遍历了包含有 n 个元素的列表一次。在表中进行的每次查找只花费 O(1) 的时间。
空间复杂度：O(n)， 所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储 n 个元素。
代码4

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

结果

golang哈希

同样哈希的思想，我们用Golang来实现一下，看看golang和c++的性能：
代码5

func twoSum(nums []int, target int) []int {
    maps := make(map[int]int)
    for index, value := range nums {
        member := target - value
        if _, ok := maps[member]; ok {
            return []int{maps[member], index}
        } else {
            maps[value] = index
        }
    }
    return []int{}
}

结果

没想到golang如此强悍。

总结

运行结果时间并不固定，和力扣的服务器繁忙度还有参数变化有关吧。空间占用是比较固定的。

排序法和哈希法在时间复杂度上的优势，注定效率高于暴力法。