two pointers(双指针思想)

双指针思想是一种很重要的、可以减少算法时间复杂度的思想。虽然它叫双指针，但和c/c++中的指针关系并不大。双指针思想本质上是对序列的两个不同的坐标（i，j）进行扫描，并减少时间复杂度。归并排序和快速排序都是利用了two pointers思想。下面来看两个问题来了解two pointers：

问题一：
给定一个正整数M和正整数递增序列，求序列中两个不同的元素a，b，它们相加后恰好等于M。

这个题可以用简单的枚举，循环嵌套，其时间复杂度为O(n²)，代码略。这在n为10⁵时是不能承受的。
之所以时间复杂度高，是因为这个枚举做了很多不必要的工作，比如，在i+j的元素等于M时，再向前枚举就没有意义了，因为之后的i+j元素之和必然大于M。
事实上，如果我们仔细思考就会发现，i和j的枚举是互相牵制的。这点可以给优化带来很大空间。下面我们来利用two pointers思想来解决一下这个问题：
令i，j分别指向序列中的第一个元素和最后一个元素，以i>=j为终止条件，让i递增，j递减，然后会出现三种情况：
1 a[i]+a[j]==M，此时找出一个解这时，只有i++，j–时才有可能找到其他解；
2 a[i]+a[j]>M,此时，只有j–才能找到其他解。
3 a[i]+a[j]<M，此时，只有i++才能找到其他解。
综合以上三种情况，可以很容易写出代码：

while(i<j){
    if(a[i]+a[j]==M){
        printf("%d %d",i,j);
        i++;
        j--;
    }
    else if(a[i]+a[j]<M)
    {
        i++;
    }
    else j--;
}

可以看出，该算法的时间复杂度为O(n)。

问题二：序列合并问题。
假设有两个递增序列A和B，要求将它们合并为一个递增序列C。
根据two pointers思想，设置两个下标i和j，分别指向序列A的第一个元素和序列B的第一个元素，然后根据A[i]与B[j]的大小来决定将哪个元素放入C。下面来看三种情况：
1 若A[i]<B[j]，则应将A[i]放入C，i++;
2 若A[i]>B[j]，则应将B[j]放入C，j++;
3 若相等，则任选1,2放。
将上述操作循环直到i，j有一个到了末位为止，此时将另一个序列全部放入C中。
代码如下：

int mergexulie(int A[],int B[],int C[],int n,int m){
    int i = 0, j = 0, index = 0;
    while(i < n && j < m){
        if(A[i]>=B[j]){
            C[index]=B[j];
            index++;
            j++;
        }
        else{
            C[index] = A[i];
            index++;
            i++;
        }
    }
    while(i < n){
        C[index] = A[i];
        index++;
        i++;
    }
    while(j < m){
        C[index] = B[j];
        index++;
        j++;
    }
    
}

下面来看归并排序。归并排序就是利用two pointers思想来实现的。首先把序列分为n/2组，每组有两个元素，然后对每组排序；然后再两两合并变成n/4组，每组进行排序…最后变为1组，再对该组进行排序。归并排序的时间复杂度是O(nlogn)。
下面来看递归实现的代码，注意，下面的mergexulie函数借鉴了上述的mergexulie函数，但有小幅度改动。

递归实现版本：

const int maxn = 100;
//mergexulie函数负责将两个序列合并成一个有序序列。
void mergexulie(int A[], int L1,int R1,int L2,int R2){
    int i = L1,int j = L2;
    int temp[maxn], index = 0;//temp临时存放合并后的数组
    while(i <=R1&&j <= R2){
        if(A[i]<=B[j]){
            temp[index]=A[i];
            index++;
            i++;
        }
        else{
            temp[index]=B[j];
            index++;
            j++;
        }
    }
    while(i <= R1){
        temp[index]=A[i];
        index++;
        i++;
    }
    while(j <= R2){
        temp[index]=B[j];
        index++;
        j++;
    }
    for(i = 0; i < index; i++){
        A[L1 + i] = temp[i];//将合并后的数值赋值给数组A
    }
}
//将array当前区间[left,right]进行归并排序
void mergesort(int A[], int left, int right){
    if(left<right){//直到left=right才达到递归边界
        int mid = (left + right) / 2;//寻找序列中点
        mergesort(A,left,mid);//对中点左边进行递归  
        mergesort(A,mid+1,right);//对中点右边进行递归
        mergexulie(A,left,mid,mid+1,right);
    }
}

非递归实现版本：

//mergexulie函数负责将两个序列合并成一个有序序列
void mergexulie(int A[], int L1,int R1,int L2,int R2){
    int i = L1,j = L2;
    int temp[maxn], index = 0;//temp临时存放合并后的数组
    while(i <=R1&&j <= R2){
        if(A[i]<=A[j]){
            temp[index]=A[i];
            index++;
            i++;
        }
        else{
            temp[index]=A[j];
            index++;
            j++;
        }
    }
    while(i <= R1){
        temp[index]=A[i];
        index++;
        i++;
    }
    while(j <= R2){
        temp[index]=A[j];
        index++;
        j++;
    }
    for(i = 0; i < index; i++){
        A[L1 + i] = temp[i];//将合并后的数值赋值给数组A
    }
}
//将array当前区间[left,right]进行归并排序
void mergesort(int A[]){
    for(int step = 2; step / 2 <= n; step = step * 2){
        //每step个元素一组，对前step/2和后step/2个元素进行合并
        for(int i = 1; i <= n; i = i+step){
            int mid = i + step / 2 - 1;
            if(mid + 1 <= n){
                mergexulie(A,i,mid,mid+1,min(i + step - 1, n));
          }
        }
    }
}

下面来讲解大名鼎鼎的快速排序。
快速排序本质上也是利用了two pointers思想。
先来看这样一个问题：对一个序列A，能否有一个算法，对序列A中的元素位置进行调整，让A[1]左边的元素都小于A[1]，A[1]右边的元素都大于A[1]。

下面用双指针思想来解决这个问题。
1 先将A[1]暂存在变量temp中，将left和right两个下表分别指向序列的头尾。
2 right不断向左移，直到right小于temp，将A[right]挪到A[left]处（此时A[left]中的元素可被覆盖）
3 left不断右移，直到left大于temp，将A[left]挪到A[right]。
4 重复2 3，直到left与right相遇，把temp放到相遇的地方。

下面来看代码：

#include <bits/stdc++.h>

using namespace std;

int qpartition(int A[], int left, int right){
    int temp = A[left];
    while(left < right){
          while(left<right && A[right] > temp)right--;//注意这里要有left < right的判断，不然会出错
          A[left] = A[right];
          while(left<right && A[left] < temp)left++;
          A[right] = A[left];
    }
    A[left] = temp;
    return left;
}
void qsort(int A[], int left, int right){
    if(left < right){
        int pos = qpartition(A, left, right);
        qsort(A, left, pos - 1);
        qsort(A, pos + 1, right);
    }
}
int main(){
    int A[5] = {5,3,4,2,1};
    qsort(A, 0, 4);
    for(int i = 0; i <5; i++){
        printf("%d", A[i]);
    }
    return 0;
}

打印结果是12345。

以上算法有一个问题，就是在序列接近有序时，快排的时间复杂度会接近O(n²)，这有点儿大了。于是，我们采用一种随机快排的方式，可以将快排的时间复杂度变为O(nlogn)。下面先来看怎么生成一定范围内的随机数。
生成随机数首先需要stdlib.h和time.h头文件。然后要在语句里加上srand((unsigned)time(NULL));，生成随机数种子，变量用
(int)(round(1.0rand()/RAND_MAX(b-a)+a))即可生成[a,b]范围内的随机数。
知道了这一点，我们就可以利用随机数来写随机快排的代码了，如下：

#include <bits/stdc++.h>

using namespace std;

int qpartition(int A[], int left, int right){
    int p = (round(1.0*rand()/RAND_MAX*(right-left)+left));//和之前的qpartition相比只需加上这行代码和第7行代码，并且改动第8行代码即可
    swap(A[left],A[p]);
    int temp = A[left];
    while(left < right){
          while(left<right && A[right] > temp)right--;//注意这里要有left < right的判断，不然会出错
          A[left] = A[right];
          while(left<right && A[left] < temp)left++;
          A[right] = A[left];
    }
    A[left] = temp;
    return left;
}
void qsort(int A[], int left, int right){
    if(left < right){
        int pos = qpartition(A, left, right);
        qsort(A, left, pos - 1);
        qsort(A, pos + 1, right);
    }
}
int main(){
    int A[5] = {5,3,4,2,1};
    qsort(A, 0, 4);
    for(int i = 0; i <5; i++){
        printf("%d", A[i]);
    }
    return 0;
}