快速排序+归并排序

int mid(int a,int b,int c)
{
    if(a > b) swap(a,b);
    if(a > c) swap(a,c);
    if(b > c) swap(b,c);
    return b;
}

void QuickSort(int a[],int L,int R)
{
    if(L >= R) return;
    int m = (R+L)/2;
    int v =  mid(a[L],a[m],a[R]); //优化选择中间位置

    int i = L,j = R;
    while(i<j)
    {
        while(a[i] < v) i++;
        while(a[j] > v) j--;
        if(i <= j)
        {
            swap(a[i],a[j]);
            i++;
            j--;
        }
    }

    QuickSort(a,L,i-1);
    QuickSort(a,i,R);
}

　　一种划分方法，划分后 所选因子 在中间

int Partition(int * R,int i,int j)
{//调用Partition(R，low，high)时，对R[low..high]做划分，
//并返回基准记录的位置
    int pivot=R[i]; //用区间的第1个记录作为基准 '
    while(i<j){ //从区间两端交替向中间扫描，直至i=j为止
        while(i<j&&R[j]>=pivot) //pivot相当于在位置i上
            j--; //从右向左扫描，查找第1个关键字小于pivot.key的记录R[j]
        if(i<j) //表示找到的R[j]的关键字<pivot.key
            R[i++]=R[j]; //相当于交换R[i]和R[j]，交换后i指针加1
        while(i<j&&R[i]<=pivot) //pivot相当于在位置j上
            i++;//从左向右扫描，查找第1个关键字大于pivot.key的记录R[i]
        if(i<j) //表示找到了R[i]，使R[i].key>pivot.key
            R[j--]=R[i]; //相当于交换R[i]和R[j]，交换后j指针减1
    } //endwhile
    R[i]=pivot; //基准记录已被最后定位
return i;
} //partition

 

#include <iostream>
#include <cstdio>
using namespace std;

int Partition(int *L,int low,int high){
    int pivotkey=L[low];
    int i = low, j = high+1;
    while(i<j){
        while (L[++i]<pivotkey && i<=high);
        while (L[--j]>pivotkey);
        if (i<j) {swap(L[i],L[j]);}
    }
    swap(L[low],L[j]);
    return j;
}

int NSort(int *L,int low,int high,int k){
    int mid;
    if(low<=high){
        mid=Partition(L,low,high);
        printf("l=%d r=%d m=%d k=%d\n",low,high,mid,k);
        if(high-mid+1==k) return L[mid];
        else if(high-mid+1<k) return NSort(L,low, mid-1, k-(high-mid+1));
        else return NSort(L,mid+1, high,k);
    }
    return 0;
}

　　归并排序

void MergeSort(int *A,int L,int R,int *B)
{
    if(R<=L) return;
    int m = (L+R)/2;
    MergeSort(A,L,m,B);
    MergeSort(A,m+1,R,B);

    int p = m+1,q=L,k=L;
    while(p <= R || q<=m)
    {
        if((q<=m && A[q]<=A[p])|| p > R)
        {
            B[k++]=A[q++];
        }
        else
            B[k++]=A[p++];
    }
    for(int i = L; i <=R; i++)
        A[i]=B[i];
}