1、Two Sum

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

基本思路就是两个循环进行查找：

#include<iostream>
#include<vector>
using namespace std;
int main()
{
	vector<int>a = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int target = 6;
	//目的是找到两个数之和是6  并且找到地址
	vector<int>index;
	for (int i = 0; i < a.size(); i++)
	{
		for (int j = i + 1; j < a.size(); j++)
		{
			if (a[i] + a[j] == target)
			{
				index.push_back(i);
				index.push_back(j);
			}
		}

	}
	for (int i = 0; i < index.size(); i++)
	{
		cout << index[i] << endl;
	}
	system("pause");
	return 0;
}

如果数组很大的时候，但是时间运行慢，不适合广度的使用

别人的思路：

1，首先同样分配一个数组空间，将数据拷贝

2，将拷贝的数组排序

3，对排序数组，建立两个查找“指针”，一个在数组头，一个在数组尾部，依次相加比较，如果大了，尾部向前进一位，如果小了，头部向后进一位，直至有相等的情况或者头部与尾部交叉的情况发生，返回结果。

class Solution {
public:
    /*Below is the 2 sum algorithm that is O(NlogN) + O(N)*/
    /*Alternative: hash从左往右扫描一遍，然后将数及坐标，存到map中。然后再扫描一遍即可。时间复杂度O(n)*/
    vector<int> twoSum(vector<int> &numbers, int target) {
        vector<int> numbersCopy;
        for(int i = 0; i < numbers.size(); i++) numbersCopy.push_back(numbers[i]);
        
        sort(numbersCopy.begin(), numbersCopy.end()); //O(NlogN)
        vector<int> returnNumbers = twoSumAlgorithm(numbersCopy, target);//O(N)
        
        vector<int> returnIndexes;
        for(int j = 0; j < returnNumbers.size(); j++)
            for(int i = 0; i < numbers.size(); i++)//O(N)
                if(numbers[i] == returnNumbers[j]) returnIndexes.push_back(i + 1);
                
        if(returnIndexes[0] > returnIndexes[1]){
            returnIndexes[0] = returnIndexes[0]^returnIndexes[1];
            returnIndexes[1] = returnIndexes[0]^returnIndexes[1];
            returnIndexes[0] = returnIndexes[0]^returnIndexes[1];
        }

        return returnIndexes;
    }
    
    /*Core algorithm is linear*/
    vector<int> twoSumAlgorithm(vector<int> &numbers, int target) {
        int len = numbers.size();
        vector<int> r;
        int i = 0; int j = len - 1;
        while(i < j){
            int x = numbers[i] + numbers[j];
            if(x == target){ 
                r.push_back(numbers[i]);
                r.push_back(numbers[j]);
                i++; j--;
            }else if(x > target) j--;
            else i++;
        }
        return r;
    }
};

对于查找这类问题来说，想减少时间复杂度的一个好办法那就是建立hash表，在这里使用map结构来完成，代码如下：

class Solution {
public:
    vector<int> twoSum(vector<int> &numbers, int target) {
        vector<int> result;
        map<int, int> m;
        if (numbers.size() < 2)
            return result;
        for (int i = 0; i < numbers.size(); i++)
            m[numbers[i]] = i;

        map<int, int>::iterator it;
        for (int i = 0; i < numbers.size(); i++) {
            if ((it = m.find(target - numbers[i])) != m.end())
            {
                if (i == it->second) continue;
                result.push_back(i+1);
                result.push_back(it->second+1);
                return result;
            }
        }
        return result;
    }
};

全部代码：

#include<vector>
#include<iostream>
#include<map>
#include<algorithm> 
using namespace std;
void twosum(vector<int>&a, int target, vector<int>&c);
void twosum1(vector<int>&a, int target, vector<int>&c);
void twosum2(vector<int>&a, int target, vector<int>&c);
int main()
{
	vector<int> a = { 1, 2, 3, 4, 6, 7, 9, 10 };
	int target = 9;
	vector<int>c;
	twosum2(a, 9, c);
	for (int i = 0; i < c.size(); i++)
		cout << c[i] << endl;



	system("pause");
	return 0;
}

void twosum(vector<int>&a, int target, vector<int>&c){
	
	for (int i = 0; i < a.size(); i++)
	{
		for (int j = i + 1; j < a.size(); j++)
		{
			if (a[i] + a[j] == target)
			{
				c.push_back(a[i]);
				c.push_back(a[j]);
			}
		}
	}
}
void twosum1(vector<int>&a, int target, vector<int>&c)
{
      map<int,int>m;
	/*  for (int i = 0; i < a.size(); i++)
	  {
		  m[a[i]] = i;

	  }*/
	  for (int i = 0; i < a.size(); i++)
	  {
		  if (m.find(target - a[i]) == m.end())
		  {
			  m[a[i]] = i;
		  }
		  if (m.find(target - a[i]) != m.end())
		  {
			  c.push_back(a[i]);
			  c.push_back(target - a[i]);
		  }
	  }

}
void twosum2(vector<int>&a, int target, vector<int>&c)
{
	sort(a.begin(), a.end());
	int i = 0;
	int j = a.size() - 1;
	while (i < j)
	{
		if (a[i] + a[j]>target)
		{
			j--;
		}
		else if (a[i] + a[j] < target)
		{
			i++;
		}
		else
		{
			c.push_back(a[i]);
			c.push_back(a[j]);
			i++;
			j--;
		}
		
	}
}