照着书写的几个经典排序算法（插入、希尔、堆、归并、快排）

这段时间楼主在忙找工作的事情，必然要把数据结构和算法部分复习一下，抽空把几个经典的排序算法写了下，一方面练习一下，另一方面以后用到了就可以直接拿去了~

几点注意：

1.大部分都是按照《数据结构与算法分析》这本书上的例子写的

2.下面例子中的希尔排序并不是最优的

#include <iostream>
#include <time.h>

using namespace std;

/************************************************************************/
/* 将常用的排序算法总结如下：                                                                     */
/************************************************************************/

//1.插入排序
template <typename T>
int InsertSort(T array[],int N)
{
    if ( array == NULL || N == 0 )
        return 1;
    T tmp;
    int j;
    for (int p=1;p<N;p++)
    {
        tmp = array[p];
        for ( j = p; j > 0 && tmp < array[j - 1]; j --  )
        {
            array[j] = array[j-1];
        }
        array[j] = tmp;
    }
    return 0;
}

//2.希尔排序(n/2)
template <typename T>
int ShellSort(T array[],int N)
{
    T tmp;
    int i,j,Increment;
    for ( Increment = N/2; Increment>0; Increment/=2 )
    {
        for (i=Increment;i<N;++i)
        {
            tmp = array[i];
            for (j=i;j>=Increment && tmp < array[j-Increment];j-=Increment)
            {
                array[j] = array[j-Increment];
            }
            array[j] = tmp;
        }
    }
    return 0;
}

//交换例程
template <typename T>
inline void swap(T *a, T *b)
{
    T temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

//3.堆排序
#define LeftChild(i) (2*(i)+1)
template <typename T>
void percdown(T array[], int i, int N)
{
    int child;
    T tmp = array[i];
    for (;LeftChild(i)<N;i=child)
    {
        child = LeftChild(i);
        if (child!=N-1 && array[child+1]>array[child])
            child ++;
        if (tmp<array[child])
            array[i] = array[child];
        else 
            break;
    }
    array[i] = tmp;
}
template <typename T>
void heapsort(T array[], int N)
{
    int i;
    for (i = N/2;i>=0;i--)
        percdown(array,i,N);
    for (i = N-1;i>0;i--)
    {
        swap(&array[0],&array[i]);
        percdown(array,0,i);
    }
}

//4.归并排序
template <typename T>
void Merge(T array[], T Tmparray[], int Lpos, int Rpos, int RightEnd)
{
    int i,LeftEnd,NumElements,Tmppos;
    LeftEnd = Rpos - 1;
    Tmppos = Lpos;
    NumElements = RightEnd - Lpos + 1;

    while(Lpos<=LeftEnd && Rpos<=RightEnd)
    {
        if (array[Lpos]<=array[Rpos])
            Tmparray[Tmppos++] = array[Lpos++];
        else
            Tmparray[Tmppos++] = array[Rpos++];
    }
    while(Lpos<=LeftEnd)
        Tmparray[Tmppos++] = array[Lpos++];
    while(Rpos<=RightEnd)
        Tmparray[Tmppos++] = array[Rpos++];

    for (i=0;i<NumElements;i++,RightEnd--)
        array[RightEnd] = Tmparray[RightEnd];
}

template <typename T>
void Msort(T array[], T Tmparray[], int left, int right)
{
    int center;
    if (left<right)
    {
        center = (left + right)/2;
        Msort(array,Tmparray,left,center);
        Msort(array,Tmparray,center+1,right);
        Merge(array,Tmparray,left,center+1,right);
    }
}

template <typename T>
void Mergesort(T array[], int N)
{
    T *Tmparray;
    Tmparray = new T[N];
    if (Tmparray!=NULL)
    {
        Msort(array,Tmparray,0,N-1);
        delete [] Tmparray;
    }
    else
        cout<<"error"<<endl;
}


//5.快速排序（编程珠玑上未优化）
template <typename T>
int qsort(T array[], int left, int right)
{
    if(left >= right)
        return 0;
    T pivot = array[left];
    int i,j;
    i = left;
    j = right+1;
    for (;;)
    {
        while(array[++i]<pivot){}
        while(array[--j]>pivot){}
        if (i<j)
            swap(&array[i],&array[j]);
        else
            break;
    }
    swap(&array[left],&array[j]);

    qsort(array,left,j-1);
    qsort(array,j+1,right);

    return 0;
}

//6.优化过的快速排序
template <typename T>
inline T median3(T array[], int left, int right)
{
    int center = (left + right)/2;

    if (array[left]>array[center])
        swap(&array[left],&array[center]);
    if (array[left]>array[right])
        swap(&array[left],&array[right]);
    if (array[center]>array[right])
        swap(&array[center],&array[right]);

    swap(&array[center],&array[right-1]);
    return array[right-1];
}

#define Cutoff 3
template <typename T>
int qsortbest(T array[], int left, int right)
{
    int i,j;
    T pivot;

    if (right - left >= Cutoff)
    {
        pivot = median3(array,left,right);
        i = left;
        j = right - 1;
        for (;;)
        {
            while(array[++i]<pivot){}
            while(array[--j]>pivot){}
            if (i<j)
                swap(&array[i],&array[j]);
            else 
                break;
        }
        swap(&array[i],&array[right-1]);

        qsortbest(array,left,i-1);
        qsortbest(array,i+1,right);
    }
    else
        InsertSort(array+left,right-left+1);
    return 0;
}




int main()
{
    int chose;
    int *array;
    int N;
    cout<<"输入数据量N: ";
    cin>>N;
    cout<<"\n输入排序方式："<<"\n1.插入排序\n2.希尔排序\n3.堆排序\n4.归并排序\n5.快速排序（编程珠玑）\n6.快速排序（优化）"<<endl;
    cin>>chose;

    double tbegin,tend;

    srand((unsigned int)time(NULL));
    array = new int[N];
    for (int i=0;i<N;++i)
    {
        *(array+i) = rand();
    }

    tbegin = (double)clock();
    switch(chose)
    {
    case 1:
        InsertSort(array,N);
        break;
    case 2:
        ShellSort(array,N);
        break;
    case 3:
        heapsort(array,N);
        break;
    case 4:
        Mergesort(array,N);
        break;
    case 5:
        qsort(array,0,N-1);
        break;
    case 6:
        qsortbest(array,0,N-1);
        break;
    }
    tend = (double)clock();
    
     for (int i=0;i<N;++i)
     {
         cout<<array[i]<<'\t';
     }
    cout<<"\n时间花费："<<tend - tbegin<<endl;

}