Two Sum（初谈双指针）

昨天晚上遇到这么一个题目，然后听到了关于“双指针”的使用。好了，言归正传，先来看一看这个题目：

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

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

1. 嵌套循环解法

首先说一下我自己在面向这个题的时候的解法：首先，我认为对该无序数组进行排序，目的是为了减少遍历时间。以题目给的数据为例：

sort(nums, nums + numsSize);
int *Result = (int*)malloc(sizeof(int)* 2);
for (int i = 0; i < numsSize - 1; i++){
for (int j = i + 1; j < numsSize; j++){
if (nums[i] + nums[j] == target){    //写入
Result[0] = nums[i];
Result[1] = nums[j];
}
if (nums[i] + nums[j] > target)    //跳出判断
break;
}
}

return Result;

但是，在通过第一组测试数据之后，出现了新的问题：

Example:
Given nums = [3, 2, 4], target = 6,
Because
nums[1] + nums[2] = 2 + 4 = 6, return [1, 2].

但是由于在前面经过了排序，数组元素的下标已经改变，所以，最后的输出结果变成了[0, 2]。

于是，不得不采用最原始的解决办法，嵌套循环全部遍历，虽然大大增加了运算时间，但是总算解决了问题，当然，代码实现也就更简单了，具体代码如下：

int *Result = (int*)malloc(sizeof(int)* 2);
for (int i = 0; i < numsSize - 1; i++){
for (int j = i + 1; j < numsSize; j++){
if (nums[i] + nums[j] == target){
Result[0] = i;
Result[1] = j;
}
}
}

return Result;

这里还有一个细节的问题，就是这个：int *Result = (int)malloc(sizeof(int)* 2);

一开始的时候，返回的这个数组我是直接定义的：int Result[2];

但是发现返回后在主函数内打印是不可行的，虽然后来改为了动态分配解决了这个问题，但是并不知道原因所在，现在了解到：

函数内开辟的这个数组空间，是存在于栈当中的，函数在完成功能后，当时使用的内存空间是拒绝再被访问的，你返回的那个数组的首地址—Result，也是毫无意义，然后动态分配的空间是存在于堆当中的，是一个共享的空间，大家都可以使用，所以，即使函数完成了功能，也是可以被主函数访问的。

关于堆和栈的更多详细的内容，我借鉴前辈的经验，也写了一点，有兴趣的可以到这里去看看关于堆和栈(直接点我)

2.双指针解法

双指针解法的优化之处在于仅需要一次遍历就可以达到目的。好，直接进入主题：

首先对该无序数组进行排序，随后用两个变量指向数组的开头和结尾：这里我们使用low和high，分别指向nums[0]和nums[numsSize];因为已经进行过排序，如果nums[low]+nums[high] < target，则说明low指向的数太小，需要往后移动；反之，则是high指向的数太大，需要前移，当两者相等，遍历结束 。

完全代码如下：

int compi(const void *a, const void *b){    //C的qsort要用的函数
return (*(int*)a - *(int*)b);
}

int* twoSum(int* nums, int numsSize, int target){
bool flag = true;
int* Result = (int*)malloc(sizeof(int)* 2);
int* temp = (int*)malloc(sizeof(int)*numsSize);  //复制数组来找真正的下标

for (int i = 0; i < numsSize; i++)
temp[i] = nums[i];

qsort(nums, numsSize,sizeof(nums[0]),compi);
int low = 0;
int high = numsSize - 1;

while (low < high){
if (nums[low] + nums[high] < target)
low++;
else if (nums[low] + nums[high] > target)
high--;
else
break;
}
//flag用于解决nums[low]和nums[high]相等造成无法给Result[1]赋值的情况
for (int i = 0; i < numsSize; i++){
if (temp[i] == nums[low] && flag==true)
{
Result[0] = i;
flag = false;
}
if (temp[i] == nums[high])
{
Result[1] = i;
}
}
//如果返回数组的数值大小不正确，交换
if (Result[0] > Result[1]){
int temp = Result[0];
Result[0] = Result[1];
Result[1] = temp;
}

return Result;
}

修改了好一阵子，终于给了AC，当然收获也是良多的，这道题也有哈希的做法，现在还不是很懂，在后面的学习中会慢慢补上这一部分，也会谈一下对栈、堆的理解。新手上路，错误之处，还望指正！