問題描述

對於一個給定的陣列，找出2個數，它們滿足2個數的和等於一個特定的數，返回這兩個數的索引。（從1開始）
Given an array of integers, find two numbers such that they add up to a specific target number.

The function twoSum should return indices of the two numbers such that they add up to the target,
where index1 must be less than index2. Please note that your returned answers (both index1 and index2)
are not zero-based.

You may assume that each input would have exactly one solution.

Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2

解決方案

1.思路分析：

我們將求2個數的索引轉換成在陣列中搜索(target-nums[i])的位置；

直觀想，兩層遍歷，固定一個元素，迴圈右移另一個元素，逐個測試，時間複雜度O(n2)，而O(n2)一般不能接受，因此需要考慮改進演算法：
想法則是降低到O(nlgn)，最理想則是O(n)

2.測試樣例：

正數、負數、0

3.特殊情況：

陣列不足2個數、兩數相加溢位、沒有匹配的情況

4.實現

4.1 兩層遍歷的實現：O(n2)

#include <iostream>
using namespace std;
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    returnSize = NULL;
    if (numsSize < 2)
        return returnSize;
    int i = -1;
    int j;
    while
 
 (++i < numsSize-1) {
        if (nums[i] >= target)
            continue;
        j = i;
        while (++j < numsSize) {
            compare_times++;
            if (nums[i] + nums[j] == target)
                break;
        }
        if (j == numsSize)
            continue;
        else
            break;     
    }
    if (i != numsSize-1) {
        returnSize = new int [2];
        returnSize[0] = i+1;
        returnSize[1] = j+1;
    }
    return returnSize;
}

int main()
{
    int nums[] = {-1, 0, 9, 5, 7, 11, 15, 20};
    int target = 9; 
    int *index = NULL;
    index = twoSum(nums, sizeof(nums)/sizeof(nums[0]), target, index);
    if(index != NULL)
       cout<<"index1 = "<<index[0]<<", index2 = "<<index[1]<<endl; 
}

提交到leetcode 返回Time Limit Exceeded，不滿足時間要求。

4.2 排序實現 O(nlgn)

首先將陣列進行快速排序或者插入到二叉搜尋樹中，二分查詢，當固定一個元素nums[i]，在陣列中查詢target - nums[i]，此時查詢時間降低到O(lgn)，總消耗即為O(nlgn)

4.3 線性實現-Hash表 O(n)

我們知道對元素的搜尋最快則是O(1)，即直接索引到，聯想只能是Hash表或者是關鍵字索引。關鍵字索引（從最小到最大）會佔用額外的記憶體空間。
由於C++有現成的hash map，所以直接採用c++。
另外我們要求的是元素的索引，即Hash表的關鍵字，所以我們把陣列元素作為Hash表的關鍵字，而把陣列元素的索引作為Hash表的元素值。

class Solution
{
public:
    vector<int> twoSum(const vector<int> &nums, int target) {
        vector<int> results;
        if (nums.size() < 2) {
            return results;
        }
        map <int , int> hmap;
        //插入到hash map
        for (int i = 0; i < nums.size(); i++) {
            hmap.insert(pair <int, int> (nums[i], i) ); //元素值做關鍵值
        }
        int j;
        for (int i = 0; i < nums.size(); i++) {
            //hmap.count(x):x在hash map中出現的次數
            if (hmap.count(target - nums[i])) {
                j = hmap[(target - nums[i])];
                if (j < i) {
                    results.push_back(j+1);
                    results.push_back(i+1);
                }
            }
        }
        return results;
    }
};

測試

int main()
{
    int nums[] = {0,-3, 2, 7, 11, 15, 20};
    vector<int> nums_v(nums, nums+7);
    int target = 9;
    while (1) {
        class Solution sol;
        vector<int> results = sol.twoSum(nums_v, target);
        if(results.size())
            cout<<"index1 = "<<results[0]<<", index2 = "<<results[1]<<endl;
    }
    getchar();
}