每天一道算法题（二）：给定数组Arr和一个整数aim,请返回哪两个位置的数可以加出aim来。

给定数组Arr和一个整数aim,请返回哪两个位置的数可以加出aim来

例如：arr={2,7,11,15},target = 9 返回{0，1}，因为arr[0] + arr[1] = 2 + 7 = 9,可以假设每个数组里只有一组答案。

大概流程是这样的：

首先，定义一个数组。记录数组的位置。将数组进行排序，在排序的过程中，如果值交换，则将保存位置的数组也随之交换

我们可以定义两个变量。一个指向数组的起始位置，一个指向数组末尾位置。

如果起始位置和末尾位置相加值大于aim,则末尾位置--。

如果起始位置和末尾位置相加值小aim,则起始位置++。

如果相等，返回数组内的原来的位置。

详细代码如下：

#include <iostream>
#include <vector>
using namespace std;

//如果交换，将辅助数组和原数组都要进行交换
void swap(vector<int> &nums, vector<int> &help,int m, int n)
{
	int tmp = nums[m];
	nums[m] = nums[n];
	nums[n] = tmp;
	
	tmp = help[m];
	help[m] = help[n];
	help[n] = tmp;
}

//构建最大堆
void maxHeap(vector<int> &nums, int start, int end, vector<int> &help)
{
	int fNode = start;
	int sNode = 2*start+1;

	while (sNode <= end)
	{
		if (sNode+1 <= end && nums[sNode] < nums[sNode+1])
			sNode++;
		if (nums[fNode] > nums[sNode]) 
			return;
		else
		{
			swap(nums,help,sNode,fNode);
			fNode = sNode;
			sNode = fNode*2+1;
		}
	}

}

//堆排序
void heapSort(vector<int> &nums, vector<int> &help)
{
	int len = nums.size();
	for(int i = len/2-1; i >= 0; i--)
	{
		maxHeap(nums, i, len-1, help);
	}
	for(int j = len-1; j >= 0; j--)
	{
		swap(nums, help, j ,0);
		maxHeap(nums,0,j-1, help);
	}
}

void twoNum(vector<int> &nums, vector<int> &help, vector<int> &res, int aim)
{
	heapSort(nums,help);
	int left = 0;
	int right = nums.size()-1;
	int sum = 0;
	while (left != right)//排序完以后进行查找
	{
		sum = nums[left] + nums[right];
		if (sum > aim)
			right--;
		if (sum < aim) 
			left++;
		if (sum == aim) 
		{
			res.push_back(left);
			res.push_back(right);
			return;
		}
	}
	res.push_back(-1);
	res.push_back(-1);
}

int main(int argc, char* argv[])
{
	vector<int> nums;
	nums.push_back(2);
	nums.push_back(11);
	nums.push_back(7);
	nums.push_back(15);
	
	vector<int> help;
	
	vector<int> res;

	for(int i = 0; i < 4; i++)
	{
		help.push_back(i);
	}

	twoNum(nums, help, res,26);

	for(i =0; i < 2; i++)
	{
		cout << res[i] << "\t" ;
	}
	cout << endl;

	cin.get();
	return 0;
}