【leetcode】167. Two Sum II - Input array is sorted

Difficulty：Medium

Given an array of integers that is already sorted in ascending order, 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

解题思路：

解法一（数据量大会超时）：

     算法主要思想是采用递归的方法，对于一个以升序排序的vector，刚开始很容易想到的是采用从尾部向前的方式，对于每一个数字，对当前的target进行做差值，将当前数向量位置的值target-nums[i]作为新的target值，将nums[0]到nums[i-1]的区间作为新的向量空间，进行递归运算。

这部分最不容易完成的就是分类讨论。

1.当nums[i]=target的时候

    1.1 nums[i]=0的情况，在这种情况下因为无论如何都是可以继续向下进行计算的，target-nums[i]=target，所以需要继续向下递归

    1.2当上层递归结果judge判断有可行方案时返回上层，返回值为1

2.当nums[i]!=target&&i>1时，继续向下递归，如果下层返回值为1，则向上返回1。

3.当i<=0&&nums[i]!=target，即当前值不是可行方案并且已遍历整个向量时，向上返回0

最后向上返回0，结束递归函数。

每一次进入下层递归前都会将这层递归的值nums[i]的值压如stack中存储，如果上层返回0，则将这层压进stack的值弹出，否则保留。如果在过程中存在可行的方案在stack中留下的数字就是方案的数值。

这样方法经过多个样例测试，各种情况考虑都是可以得到正确解的，但是由于递归的算法复杂性较高，时间复杂度为O(nlogn)这样导致在时间超出限制。

代码贴下：

bool search(vector<int>& arr,int n,int target,stack<int> &st);
class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        vector<int> arr;
	stack<int> st;
	bool judge=0;
	int pdd=numbers.size();
	judge=search(numbers,pdd,target,st);

		while(!st.empty())
	{
		int g=st.top();
		st.pop();
		g++;
		arr.push_back(g);
	}
	return arr;
    }
    
};
bool search(vector<int>& arr,int n,int target,stack<int> &st)
{
	for(int i=n-1;i>=0;i--)
	{
	     	 if(arr[i]==target) 
		{
			st.push(i);
			if(arr[i]==0&&i!=0)
			{
				bool judge=1;
				judge=search(arr,i,target-arr[i],st);
				if(judge==0) 
			{
				st.pop();
			}
			else if (judge==1) return 1;
			}
			else if(arr[i]==0&&i==0)
			{
				return 1;
			}
			return 1;
		}
		else if(i>0)
		{
				bool judge=1;
			st.push(i);
			judge=search(arr,i,target-arr[i],st);
			if(judge==0) 
			{
				st.pop();
			}
			else if (judge==1) return 1;
		}
	
		else if(i<=0&&arr[i]!=target)
		{
			return 0;
		}
	}
	return 0;
}

解法二（时间复杂度O(n)）：

   利用从两侧开始循环的方式，不在采用递归的方法

   从两侧设立头部的位置指针和尾部的位置指针，left和right，如果nums[left]+nums[right]=target时，分别将nums对应的两个值加入到存贮结果的队列中，如果大于target说明右侧尾部的数值偏大，将尾部指针-1，再次计算，如果小于target说明左侧头部的数值偏小，那么对头部指针left+1，如此循环就可以得到最终的结果。

代码如下：

class Solution {public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        	vector<int> ans;

	int left=0;int right=numbers.size()-1;
	while(left<right)
	{
		if(target==numbers[left]+numbers[right])
		{
			ans.push_back(left+1);
			ans.push_back(right+1);
			return ans;
		}
		else if(target<numbers[left]+numbers[right]) right--;
		else left++;
	}
	return ans;
    }};

对比两种方法的优势劣势：

第一种方法在时间的复杂度上相对较慢，但是第一种方法不仅仅局限于两个数值相加得到target比如可以满足：输入序列  -3 0 3 4 7

target：0    输出结果可以使 1 2 3，可以由多个数值相加得到target，应用的范围相对来说较广

第二种方法在时间复杂度上有很大的优势，当数据量比较大，计算的次数相对来说会少很多，并且代码很容易写，不需要像第一种方法考虑到很多种的情况，但是适用的范围较小，仅仅适合于2个相加得到target，应用具有一定的局限性