每日一练（1）

两数之和

给定一个整数数组 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
• 只会存在一个有效答案

最容易想到的方法是枚举数组中的每一个数 x，寻找数组中是否存在 target - x。当我们使用遍历整个数组的方式寻找 target - x 时，需要注意到每一个位于 x 之前的元素都已经和 x 匹配过，因此不需要再进行匹配。而每一个元素不能被使用两次，所以我们只需要在 x 后面的元素中寻找 target - x。

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

复杂度分析

• 时间复杂度：O(N^2)，其中 N 是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。

• 空间复杂度：O(1)。

​#include <iostream>    //用于输入输出
#include <string>    //用于处理字符串
#include <vector>    //用于存储和管理动态数组
#include <sstream>    //用于字符串流操作，支持字符串与数值之间的转换

using namespace std;

int main() {
    string input;
    getline(cin,input);    //从标准输入中读取一行字符串

    //查找nums部分
    size_t nums_start = input.find('[');    //find查找[]
    size_t nums_end = input.find(']');
    string nums_str = input.substr(nums_start + 1,nums_end - nums_start - 1);    //substr提取方括号之间的内容

    //解析 nums
    vector<int>nums;
    stringstream ss(nums_str);    //创建字符串流
    int a;
    //利用 stringstream 来依次读取整数，处理分隔符','
    while(ss >> a){
        nums.push_back(a);
        if(ss.peek() == ','){
            ss.ignore();
        }
    }

    //查找target部分，找到 target 的起始位置并转换为整数。
    size_t target_start = input.find("target = ") + 9;
    int target = stoi(input.substr(target_start));

    Solution s;
    vector<int> num = s.twoSum(nums,target);
    cout << "[" << num[0] << "," << num[1] << "]" << endl;
    
    return 0;
}

​

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

这里可以用到哈希表。

哈希表（Hash Table）：也叫做散列表。是根据关键码值（Key Value）直接进行访问的数据结构。

哈希表通过「键 key 」和「映射函数 Hash(key) 」计算出对应的「值 value」，把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做「哈希函数（散列函数）」，存放记录的数组叫做「哈希表（散列表）」。

在本题中，key = target，哈希函数为target - x，x为数组nums中的元素。我们可以创建一个hash表用于存储target - x，对于每个x，查询hash表中是否存在target - x与之相等，若存在则返回x的下标。

public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hashtable;
        for(int i = 0; i < nums.size(); i++){
            auto it = hashtable.find(target - nums[i]);
            if(it != hashtable.end()){
                return {it->second, i};
            }
            hashtable[nums[i]] = i;
        }
        return {};
    }

Hash表是一种以空间换时间的方法，能有效提高时间效率。

复杂度分析

时间复杂度：O(N)，其中 N 是数组中的元素数量。对于每一个元素 x，我们可以 O(1) 地寻找 target - x。

空间复杂度：O(N)，其中 N 是数组中的元素数量。主要为哈希表的开销。