双指针

Date：2019-07-31 19:03:46

算法实现

/*
问题描述：
    给定一个递增的正整数序列和一个正整数M，求序列中的两个不同位置的数a和b，使得它们的和恰好为M，输出所有满足条件的方案。
*/
int i=0, j=n-1;
while(i < j)
{
    if(a[i] + a[j] == m)
    {
        printf("%d %d\n", i, j);
        i++;
        j--;
    }x
    else if(a[i] + a[j] < m)
    {
        i++;
    }
    else
    {
        j--;
    }
}

/*
问题描述：
    假设有两个递增序列A和B，要求将它们合并为一个递增序列C。
*/
int Merge(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++] = A[i++];
        }
        else
        {
            C[index++] = B[j++];
        }
    }

    while(i < n)
    {
        C[index++] = A[i++];
    }
    while(j < m)
    {
        C[index++] = B[j++];
    }

    return index;
}

/*-------------------------------------2-路归并排序-----------------------------------*/

/*
递归实现
*/
const int maxn = 100;

//将数组A的[L1,R1]与[L2,R2]区间合并为有序区间（此处L2即为R1+1）
void merge(int A[], int L1, int R1, int L2, int R2)
{
    int i=L1, j=L2;
    int temp[maxn], index=0;    //temp临时存放合并后的数组，index为其下标
    while(i <= R1 && j <= R2)
    {
        if(A[i] <= A[j])
        {
            temp[index++] = A[i++];
        }
        else
        {
            temp[index++] = A[j++];
        }
    }

    while(i <= R1)
    {
        temp[index++] = A[i++];
    }
    while(j <= R2)
    {
        temp[index++] = A[j++];
    }

    for(i=0; i<index; i++)
    {
        A[L1+i] = temp[i];
    }
}

//将array数组当前区间[left, right]进行归并排序
void mergeSort(int A[], int left, int right)
{
    if(left < right)
    {
        int mid = (left + right) / 2;
        {
            int mid = (left+right) / 2;
            mergeSort(A, left, mid);
            mergeSort(A, mid+1, right);

            //将左子区间和右子区间合并
            merge(A, left, mid, mid+1, right);
        }
    }
}

/*
非递归实现
*/
void mergeSort(int A[])
{
    //step为组内元素个数，step/2为左子区间元素个数，注意等号可以不取
    for(int step=2; step/2<=n; step*=2)
    {
        //每step个元素一组，组内前step/2和后step/2个元素进行合并
        for(int i=1; i<=n; i+=step)
        {
            int mid = i + step/2 - 1;    //左子区间元素个数为step/2
            if(mid + 1 <= n)            //右子区间存在元素，则合并
            {
                merge(A, i, mid, mid+1, min(i+step-1, n));
            }

            //
            // 循环内可以用sort函数替代，会增大时间复杂度
            //
            /*
            sort(A+i, A+min(i+step, n+1));
            */
        }
    }
}

/*------------------------------------快速排序----------------------------------*/
int Partition(int A[], int left, int right)
{
    int temp = A[left];
    while(left < right)
    {
        while(left<right && A[right]>temp)
        {
            right--;
        }
        A[left] = A[right];
        while(left<right && A[left]<=temp)
        {
            left++;
        }
        A[right] = A[left];
    }
    A[left] = temp;

    return left;
}

void quickSort(int A[], int left, int right)
{
    if(left < right)
    {
        int pos = Partition(A, left, right);
        quickSort(A, left, pos-1);
        quickSort(A, pos+1, right);
    }
}

/*
生成随机数
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

int main(void)
{
    //初始化随机数种子
    srand((unsigned)time(NULL));

    printf("%d\n", RAND_MAX);
    /*
    output:
        32767
    */

    for(int i=0; i<10; i++)
    {
        //
        // rand() = [0, RAND_MAX]
        //
        // rand()%(b-a+1)+a = [a, b]
        //
        // 此时的b最大可以取RAND_MAX
        //
        printf("%d ", rand()%5+3);    //[3,7]
    }

    printf("\n");

    for(int i=0; i<10; i++)
    {
        //
        // rand()/RAND_MAX*1.0 = [0,1]
        //
        // round()四舍五入
        //
        // [0,1]*(b-a)+a = [a,b]
        //
        printf("%d ", (int)(round(1.0*rand()/RAND_MAX*50000+10000)));    //[10000,60000]
    }

    return 0;
}

/*
随机Partition
*/
int randPartition(int A[], int left, int right)
{
    //生成[left, right]内的随机数P
    int p = (round(1.0*rand()/RAND_MAX*(right-left)+left));
    swap(A[p], A[left]);

    int temp = A[left];
    while(left < right)
    {
        while(lefr<right && A[right]>temp)
        {
            right--;
        }
        A[left] = A[right];
        while(left<right && A[left]<=temp)
        {
            left++;
        }
        A[right] = A[left];
    }
    A[left] = temp;

    return left;
}