归并排序和快速排序

两种算法都使用递归函数实现，理论基础为数学归纳法。简单说，归并排序是先分开后排序，快速排序则是先排序后分开。

归并排序：

static void merge(unsigned int array[],int s,int e,int m)
{
    if(s==e)
        return;
    unsigned int left[100];
    unsigned int right[100];
    unsigned int p=0;
    unsigned int n1=m-s+1;
    unsigned int n2=e-m;

    for(int i=s;i<=m;i++)
    {
        left[p++]=array[i];
    }
    p=0;
    for(int i=m+1;i<=e;i++)
    {
        right[p++]=array[i];
    }
    int i=0;
    int j=0;
    p=s;
    for(;(i<n1)&(j<n2);)
    {
        if(left[i]<right[j])
            array[p++]=left[i++];
        else
            array[p++]=right[j++];
    }
    if(i<n1)
    {
        for(;i<n1;i++)
            array[p++]=left[i];
    }
    if(j<n2)
    {
        for(;j<n2;j++)
            array[p++]=right[j];
    }
}

static void mergesort(unsigned int array[],int s,int e)
{
    int m=(s+e)/2;
    if(s<e)
    {
        mergesort(array,s,m); //
        mergesort(array,m+1,e);//
        merge(array,s,e,m);//合并，执行到这里的前提是分开的两个序列都已经排序好了。
    }
}

快速排序：

static void swap(unsigned int * a,unsigned int* b)
{
    if(a==b)
        return;
    unsigned int t=*b;
    *b=*a;
    *a=t;
}

static int fastpartition(unsigned int array[],int s,int e)
{
    unsigned int m=array[e];
    int p=s;
    for(int i=s;i<=e-1;i++)
    {
        if(array[i]<m)
        {
            swap(&array[i],&array[p]);
            p++;
        }
    }
    swap(&array[e],&array[p]);
    return p;
}

static void fastsort(unsigned int array[],int s,int e)
{
    if(s<e)
    {
        int m=fastpartition(array,s,e); //执行的结果是array[s,m-1]都比array[m]小，array[m+1,e]都比array[m]大
        fastsort(array,s,m-1);
        fastsort(array,m+1,e);
    }
}

两个算法的性能来说差不多，快速排序稍微占优，原因在于归并排序只是简单的将序列分开，快速排序则在分开时使用了简单排序。