小白怒刷力扣hot100(C++)第一天-两数之和

一、题目

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

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

示例 3：

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

提示：

• 2 <= nums.length <= 104
• -109 <= nums[i] <= 109
• -109 <= target <= 109
• 只会存在一个有效答案

进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？

二、思路

首先我们有两种办法可以解决以上问题

(1)暴力法

如图所示，使用两层循环，当第一层循环遍历到第一个数字3时，第二层循环遍历之后所有的数字，看两数字相加是否等于target，如果不是则继续进入第一层循环遍历第二个数字，第二层循环遍历第二个数字之后的所有数字，直到两数字之和相加等于target,输出两数的数组下标。

具体实施如下：

class Solution {  
public:  
    vector<int> twoSum(vector<int>& nums, int target) {  
        // 遍历数组中的每个元素  
        for(int i = 0; i < nums.size(); i++){  
            // 对于当前元素，遍历其后面的所有元素  
            for(int j = i + 1; j < nums.size(); j++){  
                // 如果当前元素和后面的某个元素之和等于目标值  
                if(nums[i] + nums[j] == target){  
                    // 创建一个向量，存储这两个元素的索引  
                    vector<int> v{i, j};  
                    // 返回这个向量  
                    return v;  
                }  
            }  
        }  
  
        // 如果没有找到符合条件的元素对，返回一个0的向量 
        vector<int> v{0,0};
        return v;  
    } 
};

此时时间复杂度为O(n^2)，关于时间复杂度怎么计算参考博客。

如果我们想要让时间复杂度小于O(n^2)，那就要考虑第二种方法。

(2)哈希表

关于怎么理解哈希表，可以参考博客。我的理解是哈希表就像一个字典，当你想找其中储存的某一个字时，你可以一下找到，不需要遍历这本字典里的每一个字。那么接下来我们就来看看怎么用哈希表解决两数之和的问题吧。

如图所示，我们可以使用单次循环来解决这个问题，使用哈希记录已经出现过的数字，例如，当循环到第一个数字3时，计算target与3之间的差值，寻找哈希表中是否有数等于这个差值，没有则继续循环，由于此时哈希表中没有数字，在哈希表中记录下这个数字3，继续循环到第二个数字2，计算target与2之间的差值，寻找哈希表中是否有数等于这个差值，没有则继续循环，由于此时哈希表中只有第一个数字3，不等于差值，在哈希表中记录下这个数字2，继续循环到第三个数字4，计算target与4之间的差值，寻找哈希表中是否有数等于这个差值，发现第二个数字2满足差值，此时结束循环，返回这两个数字的下标。具体实现如下：

class Solution {  
public:  
    unordered_map<int,int> Hash; // 使用哈希表来存储数组元素的值与其索引的映射  
    vector<int> twoSum(vector<int>& nums, int target) {  
        for(int i = 0; i < nums.size(); i++){  
            int find = target - nums[i]; // 计算当前元素与目标值的差值  
            if(Hash.count(find) != 0){ // 如果哈希表中存在这个差值  
                vector<int> v{Hash[find],i }; // 创建一个包含当前索引和差值对应索引的向量  
                return v; // 返回这个向量  
            }  
            Hash[nums[i]] = i; // 将当前元素的值与其索引存入哈希表  
        }  
  
        return vector<int>(); // 如果没有找到任何符合条件的两个数，返回一个空的向量  
    }  
};

此时只需要一次循环，时间复杂度是O(n)。

参考文献：https://www.cnblogs.com/itdef/p/15581153.html