描述：
给定一个整数数组 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
只会存在一个有效答案来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
分析：
- 输入的是一个int型数组nums[]、目标值target。第一个要解决的就是如何读取输入的数据到内存中。
- 因为题目数组中同一个元素在答案里不能重复出现，也就是说两个下标不能重复。设从数组中取出的两个数的下标是x和y（x和y不能相等），那么x的取值范围是0~len-2，y的取指范围是x+1~len-1。用循环嵌套（两层for循环）来遍历每一种取指对，如果遇到num[x]+num[y]==target，就返回这两个下标
代码1：【暴力枚举】
class Solution {
public:
//返回值是int型的数组，两个参数分别是int型的数组nums[]，int型的整数target
vector<int> twoSum(vector<int>& nums, int target) {
int len = nums.size(); //用一个变量记录输入的数组的长度，防止多次调用计算
for( int i=0; i<len-1; i++ )
{
for( int j=i+1; j<len; j++ )
{
if( nums[i]+nums[j] == target )
return {i,j}; //表示找到了符合条件的，输出
}
}
return {}; //没找到符合条件的，输出空
}
};代码2：【哈希表】
哈希表是什么？
https://www.cnblogs.com/SlipperyJimmy/p/14750994.html#:~:text=C%2B%2B%E4%B8%AD%E5%85%B3%E4%BA%8E%E5%93%88%E5%B8%8C%E8%A1%A8%E6%9C%89%E5%BE%88%E5%A4%9A%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%EF%BC%8C%E5%B9%B3%E6%97%B6%E4%BD%BF%E7%94%A8%E7%9A%84%E6%AF%94%E8%BE%83%E5%A4%9A%E7%9A%84%E6%9C%89unordered_set,%E8%B7%9F%20unordered_map%E3%80%82
https://www.cnblogs.com/SlipperyJimmy/p/14750994.html#:~:text=C%2B%2B%E4%B8%AD%E5%85%B3%E4%BA%8E%E5%93%88%E5%B8%8C%E8%A1%A8%E6%9C%89%E5%BE%88%E5%A4%9A%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%EF%BC%8C%E5%B9%B3%E6%97%B6%E4%BD%BF%E7%94%A8%E7%9A%84%E6%AF%94%E8%BE%83%E5%A4%9A%E7%9A%84%E6%9C%89unordered_set,%E8%B7%9F%20unordered_map%E3%80%82https://www.cnblogs.com/averyfork/p/14420238.html
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> hashtable; //创建一个哈希表，key是int，value也是int
for (int i = 0; i < nums.size(); ++i)
{
auto it = hashtable.find(target - nums[i]);
//auto的原理就是根据后面的值，来自动推测前面的类型是什么。
//auto的作用就是为了简化变量初始化，如果这个变量有一个很长很长的初始化类型，就可以用auto代替。
//hashtable.find(target - nums[i]);在hashtable中查找value为target-nums[i]的，找到则返回一个迭代器，找不到返回hashtable.end()
if (it != hashtable.end()) //表示在哈希表中找到了符合条件的值，it是迭代器
{
return {it->second, i}; //返回找到的值value和另一个数在数组中的下标i
}
//为什么返回的是second的呢，因为这个哈希表将下标作为value，将数组的值作为key
//下面这个语句就是做这一步，有两种情况
//1.如果没找到，则将当前数组中的nums[i]作为hashtable的key，将下标i作为value插入哈希表
//2.如果找到了，也将当前数组中的nums[i]作为hashtable的key，将下标i作为value插入哈希表
hashtable[nums[i]] = i; //这就能保证，输出的两个下标不会重复
}
return {}; //表示没找到，返回空
}
};复杂度分析
【两个for循环】
- 时间复杂度：O(N^2)，其中 N?是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。
- 空间复杂度：O(1)。
【哈希表】
- 时间复杂度：O(N)，其中 N?是数组中的元素数量。对于每一个元素 x，我们可以 O(1) 地寻找 target - x。
- 空间复杂度：O(N)，其中 N?是数组中的元素数量。主要为哈希表的开销。
?