1. 两数之和（Hash Table）

1.题目描述

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

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

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

2.C++版本-解题方法

2.1 暴力求解:算法时间复杂度O(n²)，空间复杂度O(1)

#include <iostream>
#include <vector>
using namespace std;
/*
twoSum函数目标：
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
执行用时：616 ms, 在所有 C++ 提交中击败了32.76%的用户
内存消耗：9.2 MB, 在所有 C++ 提交中击败了21.05%的用户
*/
vector<int> twoSum(vector<int> &nums, int target) //这个地方是引用传递
{
    int i, j;
    for (i = 0; i < nums.size(); i++)
    {
        for (j = i + 1; j < nums.size(); j++) //j=i+1，不让同一个位置的数字相加
        {
            if (nums[i] + nums[j] == target)
            {
                return {i, j};
            }
        }
    }

    return {};
}
/*
    关于返回一个vec有另外一个简单写法
    上面是return 了一个 {}，也是vec的形式
    执行结果：
执行用时：780 ms, 在所有 C++ 提交中击败了16.98%的用户
内存消耗：9.2 MB, 在所有 C++ 提交中击败了17.76%的用户
*/
vector<int> twoSum02(vector<int> &nums, int target) //这个地方是引用传递
{
    vector<int> ans;
    int i, j;
    for (i = 0; i < nums.size(); i++)
    {
        for (j = i + 1; j < nums.size(); j++) //j=i+1，不让同一个位置的数字相加
        {
            if (nums[i] + nums[j] == target)
            {
                ans.push_back(i);
                ans.push_back(j);
                return ans;
            }
        }
    }
    return ans;
}

/*
主函数main
*/
int main(void)
{
    int nums[4] = {1, 2, 7, 6};
    vector<int> vec(nums, nums + 4);
    int target = 4;
    vector<int> res = twoSum(vec, target); //这个是vector的传引用
    //cout << vec << endl;//不能直接cout一个vector
    for (int i = 0; i < res.size(); ++i)
        cout << res[i] << " ";
    return 0;
}

2.2  两次hash法

        第一次是迭代将元素插入到map中，第二次是查找；

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

/*
执行用时：20 ms, 在所有 C++ 提交中击败了59.56%的用户
内存消耗：10.4 MB, 在所有 C++ 提交中击败了5.01%的用户
*/
vector<int> getSum(vector<int> &nums, int target)
{
    unordered_map<int, int> hashmap;
    for (int i = 0; i < nums.size(); i++)
    {
        //向map中添加元素
        hashmap[nums[i]] = i;
    }
    for (int i = 0; i < nums.size(); i++)
    {
        if (hashmap.count(target - nums[i]) == 1 && hashmap[target - nums[i]] != i)
        //if (hashmap.find(target - vec[i]) !=hashmap.end() && hashmap[target - vec[i]] != i)
        {
            return {i, hashmap[target - nums[i]]};
        }
    }
    return {};
}

int main()
{
    int nums[4] = {0, 3, 2, 5};
    int target = 8;
    vector<int> vec(nums, nums + 4);
    vector<int> ans = getSum(vec, target);
    for (int i = 0; i < ans.size(); i++)
    {
        cout << ans[i] << " ";
    }
    cout << endl;
    return 0;
}

2.3 一次hash法

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

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

/*
执行用时：20 ms, 在所有 C++ 提交中击败了59.56%的用户
内存消耗：10.2 MB, 在所有 C++ 提交中击败了6.91%的用户
*/
vector<int> getSum(vector<int> &nums, int target)
{
    unordered_map<int, int> hashmap;
    for (int i = 0; i < nums.size(); i++)
    {
        if (hashmap.count(target - nums[i]) > 0)
        {
            return {hashmap[target - nums[i]], i};
        }
        hashmap[nums[i]] = i; //反过来放入map中，用来获取结果下标
    }

    return {};
}

int main()
{
    int nums[4] = {0, 3, 2, 5};
    int target = 8;
    vector<int> vec(nums, nums + 4);
    vector<int> ans = getSum(vec, target);
    for (int i = 0; i < ans.size(); i++)
    {
        cout << ans[i] << " ";
    }
    cout << endl;
    return 0;
}