指针的进阶应用之双指针、三指针

在牛客网和leetcode等网站刷题的过程中，时常会遇到一些使用双指针和三指针解决问题的实例。今天，我来介绍这两种方法，相信你会对指针的应用会提高一个档次。

移除元素

题目链接

在这里，题目的要求是返回删除元素后数组的元素新长度，我修改一下，直接打印出修改完的数组的元素

假设，数组元素为0,1,2,2,3,0,4,2，我要删除元素大小为2的所有元素。

不使用指针的方法

首先选择采用不使用指针的方法。

我定义变量i，让i从0开始，增大到为数组长度减一，让arr[i]遍历一遍数组。

如果在期间寻找到与要删除的数字相同的元素时，如:

arr[i]找到元素时，此时的arr[i]等于要删除的数字，那么我就让后面的数字依次往前替换，同时，数组的长度减一。

最后数组的长度减一。（因为最后一个元素也已经被拷贝到前面去了）。

观察可以发现，刚才的2的元素已经被覆盖掉了，但是由于向前覆盖，arr[i]现在的位置又出现了一个2，这里就有一个小技巧，当arr[i]是要删除的数字时，覆盖以后，i不进行增加，让程序再次检查arr[i]的位置。

代码的实现如下:

#include<stdio.h>
void print(int arr[],int len)               //打印函数
{int i = 0;for(i = 0; i < len; i++){printf("%d ",arr[i]);}printf("\n");
}
int main()
{int arr[] = {0,1,2,2,3,0,4,2};            //需要进行删除的数组int val = 2;                              //需要删除的元素大小int i = 0;int j = 0;int len = sizeof(arr)/sizeof(arr[0]);while(i < len)                           //下标要小于数组的元素个数{if(arr[i] == val)                    //数组元素等于要删除的元素大小{j = i;                           //利用j值进行移动，防止i值的改变while(j < len-1){arr[j] = arr[j+1];           //往前替代j++;}len--;                           //数组的长度减一}else{i++;                             //数组元素不等于要删除的元素大小，i值加一，arr[i]向后寻找}}print(arr,len);return 0;
}

运行结果如下:

由运行结果可知，该代码满足了我们的要求，但是代码满足要求就足够了吗？

这串代码的时间复杂度是:O(N^2)
空间复杂度是:O(1)

接下来，我来使用另外一种方法。

采用创建新数组和使用双指针的方法

如图，我创建一个新数组。

接下来，让指针src和指针dest分别指向原数组和新数组。

如果指针src指向的元素不是2时，将指针src指向的内容赋值到指针dest指向的空间。

代码的实现如下:

#include<stdio.h>
void print(int arr[],int len)               //打印函数
{int i = 0;for(i = 0; i < len; i++){printf("%d ",arr[i]);}printf("\n");
}
int main()
{int arr[] = {0,1,2,2,3,0,4,2};            //需要进行删除的数组int arr1[20] = {0};int val = 2;                              //需要删除的元素大小int* src = arr;                     int* dest = arr1;int i = 0;int j = 0;int len = sizeof(arr)/sizeof(arr[0]);while(i < len){if(*(src + i) != val)                //指针(src+i)不等于val时，赋值到指针(dest+i)指向的空间，i++，j++{*(dest + j) = *(src + i);i++;j++;}else                                //指针(src+i)等于val时，i++,找到下一个元素{i++;}}print(arr1,j);                         //打印arr1数组中的j个元素return 0;
}

运行结果如下:

由该运行结果可以得知，该代码依然可以满足我们的要求，现在，我来研究该代码的效率。

这串代码的时间复杂度是O(N)
空间复杂度是O(N)

显然，这一串代码是空间换取时间的典型例子，但是双指针的优点还是没有完全发挥出来，接下来，我来实现另外的一种代码，完全发挥出双指针的优点。

使用双指针
我定义两个指针，分别是指针src和指针dest，开始的时候，这两个指针都指向了数组的第一个元素。

接下来，我需要遍历一次数组，如果指针src指向的内容等于要删除数字的值的话，指针src向后走一步，如果指针src指向的内容不等于要删除数字的值的话，那么将指针src指向的内容赋值到指针dest指向的内容，并且两个指针向后走一步。

#include<stdio.h>
void print(int arr[],int len)               //打印函数
{int i = 0;for(i = 0; i < len; i++){printf("%d ",arr[i]);}printf("\n");
}
int main()
{int arr[] = {0,1,2,2,3,0,4,2};            //需要进行删除的数组int arr1[20] = {0};int val = 2;                              //需要删除的元素大小int* src = arr;                     int* dest = arr1;int i = 0;int j = 0;int len = sizeof(arr)/sizeof(arr[0]);while(i < len){if(*(src + i) != val)                //指针(src+i)不等于val时，赋值到指针(dest+i)指向的空间，i++，j++{*(dest + j) = *(src + i);i++;j++;}else                                //指针(src+i)等于val时，i++,找到下一个元素{i++;}}print(arr1,j);                         //打印arr1数组中的j个元素return 0;
}

运行结果如下:

由运行结果可以得知，该串代码符合我们的要求。

这串代码的时间复杂度:O(N)
空间复杂度:O(N)

删除有序数组中的重复项

题目链接

假设在数组元素为0,0,1,1,1,2,2,3,3,4，我要删除一些重复的数组，并且只留下其中一个。

去重算法
使用两个指针src和dest，开始时都指向数组的第一个元素，如果两个指针src和dest的内容相等的话，那么指针src向后走一步，如果两个指针src和dest的内容不相等的话，就将指针src指向的内容赋值到指针dest指向的后面一步的空间。

代码的实现如下:

#include<stdio.h>
void print(int arr[],int len)               //打印函数
{int i = 0;for(i = 0; i < len; i++){printf("%d ",arr[i]);}printf("\n");
}
int main()
{int arr[] = {0,0,1,1,1,2,2,3,3,4};int* src = arr;                         //指针src存储数组首元素的地址int* dest = arr;                        //指针dest存储数组首元素的地址int i = 0;int j = 0;int len = sizeof(arr)/sizeof(arr[0]);while(i < len)                          //i要小于数组长度，不用判断j，因为i肯定会先达到大于数组长度的条件{if(*(dest + j) == *(src + i))       //如果两个指针指向的内容相等，src指针要向后走一步，i++可以实现该效果{i++;}else                                //如果两个指针指向的内容不相等，dest指针向后走一步。src指针指向的内容赋值到指针dest指向的内容，然后i++{j++;*(dest + j) = *(src + i);i++;}}print(arr,j + 1);return 0;
}

运行结果如下:

由运行结果可以得知，该代码符合我们的要求。

观察可以发现，去重算法依然是以双指针为基础，进行操作的，可见双指针运用的广泛。

这串代码的时间复杂度是:O(N)
空间复杂度是:O(1)

合并两个有序数组

在这道题中，有两个版本，一个较为简单，一个较为难。leetcode上这一道题是难的版本，而我要先讲解简单版本。

题目要求：给你两个按递增顺序排列的整数数组nums1 和nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你合并 nums2 和 nums1 ，使合并后的数组同样按递增进行排列。

假设nums1的数组元素是1,2,3,5,6,9，nums2的元素是2,5,6。

我依然采用双指针的方法，先创建一个新数组和两个指针，第一个指针指向nums1的第一个元素，第二个指针指向nums2的第一个元素，比较这两个指针指向的内容谁大谁小，小的就赋值到新数组。

然后继续遍历，直到数组nums1和数组nums2的元素都已经被赋值到新数组中。

代码的实现如下:

#include<stdio.h>
void print(int arr[],int len)               //打印函数
{int i = 0;for(i = 0; i < len; i++){printf("%d ",arr[i]);}printf("\n");
}
int main()
{int arr1[] = {1,2,3,5,6,9};int arr2[] = {2,5,6};int arr[20] = {0};                              //创建新数组int* src1 = arr1;                               //创建一个指针指向数组arr1的首元素地址int* src2 = arr2;                               //创建一个指针指向数组arr2的首元素地址int i = 0;int j = 0;int k = 0;int len1 = sizeof(arr1)/sizeof(arr1[0]);int len2 = sizeof(arr2)/sizeof(arr2[0]);while(i < len1 && j < len2)                     //i值和j值分别小于数组对应长度，就进入循环    {if(*(src1 + i) < *(src2 + j))               //*(src1 + i)指向的元素较小，将*(src1 + i)赋值到新数组中{arr[k] = *(src1 + i);k++;                                    //k++，保证赋值到新数组的下一个位置i++;                                    //i++，保证被复杂过的元素不再被复制}else{arr[k] = *(src2 + j);                   //*(src2 + j)指向的元素较小，或者两个指针指向的元素相等(复制哪个指针的内容都可以)，将*(src2 + j)的元素赋值到新数组k++;                                    //k++，保证赋值到新数组的下一个位置j++;                                    //j++，保证被复制过的元素不再被复制}}if(j >= len2)                                   //当*(src2 + j)走完arr2数组，而*(src1 + i)还没有走完arr1数组的情况{while(i < len1){arr[k] = *(src1 + i);k++;i++;}}if(i >= len1)                                    //当*(src1 + i)走完arr2数组，而*(src2 + j)还没有走完arr2数组的情况{while(j < len2){arr[k] = *(src2 + j);k++;j++;}}print(arr,k);return 0;
}

运行结果如下:

由运行结果可以得知，此串代码符合我们的要求。

这串代码的时间复杂度是O(N)
空间复杂度是O(N)

接下来，我来实现较难的版本，注意在这一道题中，两个版本的题目是不一样的，所以时间复杂度和空间复杂度不做比较。

题目要求:给你两个按递增顺序排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你合并 nums2 到 nums1 中，使合并后的数组同样按递增顺序排列。

题目链接

假设第一个数组的元素是:1,2,3,0,0,0，第二个数组的元素是2,5,6，第一个数组后面留三个是给第二个数组的元素留的位置，所以第一个数组只看前三个元素，是递增顺序的。

在这一版本中，不再要求我们合并到一个新的数组，而是要合并到第一个数组中，并且还要按照递增的顺序进行排列。

那么，在这一版本中，就要引入三指针的方法。

先定义三个指针分别是src1、src2、dest，指针src1指向第一个数组递增顺序中的最后一个元素（也就是3）。指针src2指向第二个数组的最后一个元素，也就是6，指针dest指针指向第一个数组最后一个元素（包括非顺序的），如下:

接下来，比较指针src1和指针src2指向的内容，哪个指针指向的内容大时，就赋值到指针dest指向的空间处，并且该指针和指针dest向前走一步。

代码的实现如下:

#include<stdio.h>
void print(int arr[],int len)               //打印函数
{int i = 0;for(i = 0; i < len; i++){printf("%d ",arr[i]);}printf("\n");
}
int main()
{int arr1[] = {1,2,3,0,0,0};int arr2[] = {2,5,6};int len1 = sizeof(arr1)/sizeof(arr1[0]);int len2 = sizeof(arr2)/sizeof(arr2[0]);int* str1 = arr1;      int* str2 = arr2;             int* dest = arr1;             int i1 = len1 - len2 - 1;     //让arr1加该值，len1的值为6，len2的值为3，len1减len2得到3，3再减一得到2，arr是数组首元素地址，arr+2找到3的位置int i2 = len2 - 1;            //让arr2加该值，找到数组arr2的最后一个元素int j = len1 - 1;             //让arr1加该值，找到数组arr1的最后一个元素while(i1 >= 0 && i2 >= 0)     //i1和i2的值要大于0，防止越界{if(*(str1 + i1) > *(str2 + i2))         //*(str1 + i1)大于*(str2 + i2)时，将*(str1 + i1)的值赋值到*(dest + j){*(dest + j) = *(str1 + i1);i1--;                               //i1减减，找到数组arr1的上一个元素j--;                                //j减减，继续覆盖元素}else{*(dest + j) = *(str2 + i2);        //*(str2 + i2)大于*(str1 + i1)时，或者*(str2 + i2)等于*(str1 + i1)时(复制哪个值都可以)，将*(str2 + i2)的值赋值到*(dest + j)i2--;                              //i1减减，找到数组arr2的上一个元素j--;                               //j减减，继续覆盖元素}}while(i2 >= 0)                             //i1没有遍历完没关系，因为就是要覆盖到数组arr1，要保证i2遍历完{*(dest + j) = *(str2 + i2);i2--;j--;}print(arr1,len1);return 0;
}

运行结果如下:

由运行结果可以得知，此串代码符合我们的要求。

这串代码的时间复杂度:O(N)
空间复杂度:O(1)

今天，对于指针讲解就到处结束了，指针是非常重要的东西，特别是后面数据结构的学习中，指针更是频繁使用，所以对于指针掌握要求应当更高。

关注点一点，下期更精彩。