归并排序，堆排序，快排的简单实现

归并排序：

const int sentinelcard=100000000;
 
void merge_sort(int *pData,int pBegin,int pEnd)
{
    if(!pData||pEnd=<pBegin)
        return;
    int pMiddle=(pBegin+pEnd)/2;
    merge_sort(pData,pBegin,pMiddle);
    merge_sort(pData,pMiddle+1,pEnd);
    merge(pData,pBegin,pMiddle,pEnd);
    return;
}
 
void merge(int *pData,int pBegin,int pMiddle,int pEnd)
{
    if(!pData)
        return;
    if(pEnd>=pMiddle&&pMiddle>=pBegin)
    {
        int llength=pMiddle-pBegin+1;
        int rlength=pEnd-pMiddle;
        int *lData=new int[llength+1];
        int *rData=new int[rlength+1];
        for(unsigned i=0;i<llength;++i)
            lData[i]=pData[pBegin+i];
        lData[llength]=sentinelcard;
        for(unsigned j=0;j<rlength;++j)
            rData[j]=pData[pMiddle+j+1];
        rData[rlength]=sentinelcard;
        int i=0;
        int j=0;
        for(unsigned int n=pBegin;n<=pEnd;++n)
        {
            if(lData[i]>rData[j])
            {
                pData[n]=rData[j];
                ++j;
            }
            else
            {
                pData[n]=lData[i];
                ++i;
            }
        }
        delete[] lData;
        delete[] rData;
        lData=NULL;
        rData=NULL;
    }
    return;
}

快排：

void Quick_sort(int *pData,int pBegin,int pEnd)
{
    if(!pData||pBegin>=pEnd)
        return;
    int q=partition(pData,pBegin,pEnd)
    Quick_sort(pData,pBegin,q-1);
    Quick_sort(pData,q+1,pEnd);
    return;
}
 
int partition(int *pData,int pBegin,int pEnd)
{
    if(!pData)
        return pBegin;
    int pos=pBegin;
    int lastnum=pData[pEnd];
    for(unsigned int i=pBegin;i<=pEnd;++i)
    {
        if(pData[i]<lastnum)
        {
            int tmp=pData[i];
            pData[i]=pData[pos];
            pData[pos]=pData[i];
            pos+=1;
        }
    }
    
}

堆排序:

inline int Right(int i)
{
    return(2*i+2);
}
 
inline int Left(int i)
{
    return(2*i+1);
}
 
void Maxheapify(int *pData,int i,int length)
{
    if(!pData)
        return;
    int left=Left(i);
    int right=Right(i);
    int largest=i;
    if(left<=length-1&&pData[i]<pData[left])
        largest=left;
    if(right<=length-1&&pData[largest]<pData[right])
        largest=right;
    if(largest!=i)
        swap(pData[largest],pData[i]);
        Maxheapify(pData,largest,length);
    return;
}
 
 
void BuildMaxHeap(int *pData,int length)
{
    if(!pData||length==0)
        return;
    for(int i=(length-1)/2;i>=0;--i)
    {
        Maxheapify(pData,i,length);
    }
    
}
 
void Heap_sort(int *pData,int length)
{
    if(!pData||length==0)
        return;
    BuildMaxHeap(pData,length);
    for(int i=length-1;i>=1;--i)
    {
        swap(pData[i],pData[0]);
        Maxheapify(pData,0,i-1);
    }
}