64 两数之和（Two Sum）

1 题目

题目：两数之和（Two Sum）
描述：给一个整数数组，找到两个数使得他们的和等于一个给定的数 target。你需要实现的函数twoSum需要返回这两个数的下标, 并且第一个下标小于第二个下标。注意这里下标的范围是 0 到 n-1。可以假设只有一组答案。

lintcode题号——56，难度——easy

样例1：

输入：
numbers = [2,7,11,15]
target = 9
输出：[0,1]
解释：numbers[0] + numbers[1] = 9

样例2：

输入：
numbers = [15,2,7,11]
target = 9
输出：[1,2]
解释：numbers[1] + numbers[2] = 9

2 解决方案

2.1 思路

  一种思路是先对数组排序，使用两个指针分别从头尾开始向中间走，若指针指向的两个值的和小于目标值，则左指针往右一步，若大于目标值，则右指针往左一步，直到找到结果。
  另一种思路是只进行一次循环，将走过的值放入哈希表，每次通过目标值减去当前值的结果在哈希表中查找，如果找到则成功配对。

2.2 时间复杂度

  使用排序+对向双指针的方式，时间复杂度为O(n * log n)。
  使用哈希表的方式，时间复杂度为O(n * log n)。

2.3 空间复杂度

  使用排序+对向双指针的方式，使用vector数据结构，空间复杂度为O(n)。
  使用哈希表的方式，使用set数据结构，空间复杂度为O(n)。

3 源码

3.1 排序 + 对向双指针法

细节：

1. 时间复杂度O(nlogn)，空间复杂度O(n)。
2. 排序时需要记住原序号，使用vector<pair<value, index>>可以兼顾排序且记录原序号。

C++版本：

/**
     * @param numbers: An array of Integer
     * @param target: target = numbers[index1] + numbers[index2]
     * @return: [index1, index2] (index1 < index2)
     */
    vector<int> twoSum(vector<int> &numbers, int target) {
        // write your code here
        vector<int> result;
        if (numbers.size() < 2)
        {
            return result;
        }

        // 记录数组元素的下标
        vector<pair<int, int>> numbersMap;
        for (int i = 0; i < numbers.size(); i++)
        {
            numbersMap.push_back({numbers.at(i), i});
        }

        // 对数组排序
        sort(numbersMap.begin(), numbersMap.end());

        // 对向双指针
        int left = 0;
        int right = numbersMap.size() - 1;
        while (left < right)
        {
            int leftValue = numbersMap.at(left).first;
            int rightValue = numbersMap.at(right).first;
            if (leftValue + rightValue < target)
            {
                left++;
                continue;
            }
            else if (leftValue + rightValue > target)
            {
                right--;
                continue;
            }
            else
            {
                int minIndex = min(numbersMap.at(left).second, numbersMap.at(right).second);
                int maxIndex = max(numbersMap.at(left).second, numbersMap.at(right).second);
                result.push_back(minIndex);
                result.push_back(maxIndex);
                break;
            }
        }

        return result;
    }

3.2 哈希表法

细节：

1. 时间复杂度O(n)，空间复杂度O(n) 。
2. 哈希表可以使用unordered_map<value, index>来创建。
3. 一边遍历每个数一边加入哈希表，这样可以排除重复的问题，比提前创建完整的哈希表更有优势。

C++代码：

/**
* @param numbers: An array of Integer
* @param target: target = numbers[index1] + numbers[index2]
* @return: [index1, index2] (index1 < index2)
*/
vector<int> twoSum(vector<int> &numbers, int target) {
    // write your code here
    vector<int> result;
    if (numbers.empty())
    {
        return result;
    }

    unordered_map<int, int> numbersMap; // 哈希表
    for (int i = 0; i < numbers.size(); i++)
    {
        int temp = target - numbers.at(i);
        if (numbersMap.find(temp) != numbersMap.end())
        {
            int minIndex = min(numbersMap.at(temp), i);
            int maxIndex = max(numbersMap.at(temp), i);
            result.push_back(minIndex);
            result.push_back(maxIndex);
            break;
        }
        numbersMap.insert({numbers.at(i), i});
    }

    return result;
}