剑指Offer 两数之和 C++实现

题目描述
给出一个整数数组，请在数组中找出两个加起来等于目标值的数，
你给出的函数twoSum 需要返回这两个数字的下标（index1，index2），需要满足 index1 小于index2.。注意：下标是从1开始的
假设给出的数组中只存在唯一解
例如：
给出的数组为 {20, 70, 110, 150},目标值为90
输出 index1=1, index2=2

解法

1、暴力解法
两层循环

class Solution {
public:
    /**
     * 
     * @param numbers int整型vector 
     * @param target int整型 
     * @return int整型vector
     */
    vector<int> twoSum(vector<int>& numbers, int target) {
        // write code here
        int a1, a2;
        vector<int> r;
        for(a1 = 0; a1 < numbers.size() - 1; a1++)
        {
            for(a2 = a1 + 1; a2 < numbers.size(); a2++)
            {
                if(numbers[a1] + numbers[a2] == target)
                {
                    r.push_back(a1 + 1);
                    r.push_back(a2 + 1);
                    return r;
                }
                    
            }
        }
    }
};

时间复杂度O(n^2)
空间复杂度O(1)

2、利用map
这个方法是看题解的，hash表查找效率很高，因此可以减小时间复杂度

class Solution {
public:
    /**
     * 
     * @param numbers int整型vector 
     * @param target int整型 
     * @return int整型vector
     */
    vector<int> twoSum(vector<int>& numbers, int target) 
    {
         // 返回数组，记录两个下标
        vector<int> res;
        unordered_map<int, int> mymap;
        // 建立hash table
        for(int i = 0; i < numbers.size(); i++)
        {
            mymap.insert(map<int, int>::value_type(numbers[i], i));
            
        }
        // 第二次遍历，查询是否存在当前数的complement在hash table中
        for(int i=0; i<numbers.size(); i++)
        {
            int complement = target - numbers[i];
            if(mymap.count(complement)!= 0 && mymap.at(complement)!= i)
            {
                if (i < mymap.at(complement)){
                    res.push_back(i + 1);
                    res.push_back(mymap.at(complement) + 1);
                }
                else{
                    res.push_back(mymap.at(complement) + 1);
                    res.push_back(i + 1);
                }
                return res;
            }
        }
        
        return {};
    }
};

时间复杂度O(n)
空间复杂度O(n)