双指针的应用

今天我们来说一个指针中比较高级的用法，双指针其实听到名字可能没什么感觉，但是其实举几个例子大家会发现我们可能使用过它。只不过不知道他的具体名字罢了。双指针顾名思义肯定就是两个指针的操作，第一个demo就是两个指针方向相反的时候的一个用途。当我们一个数组是有序排列的时候比如这个数组是{1,4,7,9,11,22}创建了一个这样的数组，但是现在给了你一个key值就是要求里面的两个数加起来等于这个key值，就比如说我让这个key值等于16返回他们两个的数组下标，显而易见的就是7+9=16，所以return的就是下标2和3，这个问题其实看着大家可能绝对不复杂，甚至你可以让他无序都可以完成这个要求，接下来就说一种跟双指针这东西无关，但是也可以实现这个需求的伪代码。

这里写的很简略其实就是通过双重for循环然后遍历整个数组 让每个元素都相加在判断是否能得到key值 并且输出index 但是显而易见这方法有着弊端，那就是时间复杂度太大了 O(N^2)有点难以接受

```c

void test()
{
    int arr[5]={1,4,7,9,11,22};
    int n=6;
    for(int i=0;i<n;i++)
    {
    for(intj= j=0;j<n;j++)
        if(arr[i]+arr[j]==key)
    }
}```

接下来便是双指针的方法，首先必须肯定的是上面的代码修修补补后肯定可以达到需求，但是当数组比较大的时候很难忽视时间。所以我们看看双指针的方法，首先双指针返回的是储存着两个元素的int类型指针，接着一行一行的看代码，size一看就是数组的大小不用说了，target就是key值。定义的i和j就是数组的下标，进入循环因为是有序的所以i下标的对应的是最小值，j下标对应的是最大值，所以进入循环的条件就是i小于j，sum就是两个值的和如果sum=target，直接跳出循环
外面分配的有一个能储存两个int类型的数组ret，输出ret[0]和ret[1]就是下标。如果sum不等于target，sum太大了并且i和j没有相遇的话，那么我们就把j往前面移动，前面的值比较小，如果sum小于target那么证明sum太小了需要把i往后面移动变得更大，当i和j相遇的时候这时候证明所有的值没有满足的，因为他是有序的，所以直接返回NULL指针。这里只要ret存在那我们就可以打印输出两个下标。这个方法的有点就是速度非常的快，如果数据量足够大就算无序，先用排序算法然后再进行双指针的方式应该都比上面一种方式好。

int* twoNum(int data[], int size, int target)
{
        int i = 0;
        int j = size - 1;
        while (i<j)
        {
               int sum = data[i] + data[j];
               if (sum == target) break;
               if (sum < target)
               {
                       i++;
               }
               if (sum > target)
               {
                       j--;
               }
        }
        if (i >= j)
        {
               return NULL;
        }
        int* ret = malloc(sizeof(int)*2);
        ret[0] = i + 1;
        ret[1] = j + 1;
        return ret;
}
int main(void)
{
        int arr[] = { 2,7,11,15,18,30};
        int target = 26;
        int *ret=twoNum( arr, sizeof(arr)/sizeof(arr[0]), target);
        if (ret)
        {
               printf("%d %d\n", ret[0], ret[1]);
        }
        else
        {
               printf("找不到\n");
        }
        getchar();
        return 0;
}

双指针的应用当然不止这些东西，我们在数据结构链表的时候总是有这个问题就是将两个链表或者是数组merge在一起，这里我们就将两个数组merge在一起，其实这很简单，直接无脑拼接在一起，链表的话直接指针指向，然后再写一个排序算法。但是这样的效率显而易见是非常低下的啊。如果数据量很大的话，排序算法的性能就会要求很高。我们可以先把两个小的数组进行排序，再用一个新的数组ret去接收它们的merge数组。代码如下：

int* merge(int data1[], int m, int data2[],int n)
{
        int i = 0;
        int j = 0;
        int* ret = malloc(sizeof(int) * (m + n));
        int k = 0;
        while (i < m && j < n)
        {
               if (data1[i] < data2[j])
               {
                       ret[k] = data1[i++];
               }
               else
               {
                       ret[k++] = data2[j++];
               }
        }
        while(i < m)
        {
               ret[k++] = data1[i++];
        }
        while (j < n)
        {
               ret[k++] = data2[j++];
        }
        return ret;
}
int main()
{
        int arr1[] = { 2, 5, 8, 10 };
        int arr2[] = { 1,2,6,9,11 };
        int* ret = merge(arr1, sizeof(arr1) / sizeof(arr1[0]),arr2, sizeof(arr2) /  sizeof(arr2[0]));
        int n = sizeof(arr1) / sizeof(arr1[0]) + sizeof(arr2) / sizeof(arr2[0]);
        for (int i = 0; i <n ; i++)
        {
               printf("%d", ret[i]);
        }
        getchar();
        return 0;
}

这时候看代码我们应该知道这其实两个指针指向的是相同方向，然后呢仔细看代码，其实就先给ret分配空间然后呢就将i和j都在数组开始的下标下面循环，如果第一个数组的第一个值小于第二个，那么ret就接受第一个数组的第一个值，并且那里执行i++其实就在不断地循环往复，直到i走到末尾或者j走到末尾，这时候细心的人能发现有大bug啊，如果i走完了j没走完j后面的呢就不要了吗？其实由于我们已经排过序了，将后面的直接merge到ret后面就可以了。