找出和为目标值的两个数的下标#算法#

##题目如下：
Given an array of integers, return indices of the two numbers such that they add up to a specific target.
You may assume that each input would have exactly one solution, and you may not use the same element twice.
翻译：给定一个整数的数组，返回和为一个特定目标数的两个数的下标。可以假设（认为）每个输入有且只有一个结果，且相同的数不能用到两次。
Example:

Given nums = [2, 7, 11, 15], target = 9,
Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

##思路一
看到这个题目，首先很容易想到的方法就是穷举所有可能的两数相加，即遍历两次，直到找到为止，这种算法的时间复杂度为$O(n^2)$，空间复杂度为O(1)。
代码如下：

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

##思路二
容易想到的方法往往效率不高，再往深一层想，能想到的就是要找到两个数相加为某个数，这个选择跟大小有关系，因为如果两个数相加大于目标数，那其他比这两个数都大的数对是没必要考虑的，所以如果是排好序的数组，就相对容易找了，一个方法是从有序数组的两端往中间靠拢（见以下代码），这样寻找的时间复杂度为O(n)，而排序的最佳时间复杂度为O(nlogn)，总的时间复杂度为O(nlogn)，不会差于思路一的复杂度。
代码如下：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
    	vector<int> result;
    	int size = nums.size();
		vector<NumIdx> numIdxs;
        for(int i = 0; i < size; i++){
        	struct NumIdx numIdx = {nums[i], i};
        	numIdxs.push_back(numIdx);
        }
        sort(numIdxs.begin(), numIdxs.end(), 
	        [](const NumIdx &a,const NumIdx &b)->bool{
				return a.num < b.num;  
			});
        int left = 0;
        int right = size - 1;
        while (left < right){
        	int sum = numIdxs[left].num + numIdxs[right].num;
        	if(sum == target){
    		    result.push_back(numIdxs[left].index);
    			result.push_back(numIdxs[right].index);
    			return result;
        	}
        	else if(sum < target) left++;
        	else right--;
        }
        return result;
    }
private:
	// 定义一个存储数据和原下标的结构体
	struct NumIdx{
		int num;
		int index;
	};
};

##思路三
虽然思路二时间复杂度有所下降，但有没有更好的方法呢?再次回到思路一，在第一层遍历时，先确定了一个数a，第二层遍历是要找到剩下的数中有没有符合条件的数（可确定的一个数），即target - a，有没有什么办法可以快速找到符合条件的数的下标，从而避开这第二层遍历呢？可以想到建立查询的数据结构，实现数据到下标的映射，比如Hash表，查询的时间复杂度为O(1)。
先把所有数据和相应下标i作为键值对，存入Hash表中，遍历的时间复杂度为O(n)；第二次遍历所有数据，对于每一个数据a，查询Hash表中是否有等于target - a的key，若有（且其下标与a下标不同），则获取其value（即下标），每次查询的时间复杂度为O(1)，遍历的时间复杂度为O(n)。总的时间复杂度为O(n)。但是Hash表需要的一定的存储空间，时间和空间往往不可兼得。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
    	vector<int> result;
    	int size = nums.size();
    	map<int, int> Map;
        for(int i = 0; i < size; i++){
        	Map[nums[i]] = i;
		}
		for(int i = 0; i < size; i++){
			map<int, int>::iterator it = Map.find(target - nums[i]);
        	if(it != Map.end() && it->second != i){
        		result.push_back(i);
        		result.push_back(it->second);
                return result;
			}
		}
        return result;
    }
};

以下为思路一（下）和思路三（上）在LeetCode上提交成功的截图，很明显思路三的运行时间(8 ms)短了很多，足见其降低时间复杂度的可行性。

以下是思路二提交了两次的结果，其速度也可媲美思路三：

##思路三改进
思路三需要两次遍历，其实不一定需要把所有数据都加入hash表，因为可能在前几个数就能找到结果了。出于这个考虑，可以在一边查询一边把数加入hash表。代码如下：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> result;
        int size = nums.size();
        map<int, int> Map;
        for(int i = 0; i < size; i++){
            map<int, int>::iterator it = Map.find(target - nums[i]);
            if(it != Map.end()){
                result.push_back(i);
                result.push_back(it->second);
                return result;
            }
            Map[nums[i]] = i;
        }
        return result;
    }
};

但这样其实性能不一定比原来好，因为如果两个数其中有一个在最后一个位置，那么需要n次查询和插入，但原来的方法可能不需要那么多次查询就能找到。这种方法的好处就在于，可以尽量减少插入消耗的时间。