二哥学算法之归并排序和希尔排序

归并排序是“分治”法一个很典型的应用。它比较稳定，时间复杂度也比较好，最坏也只是$ON(log_2N)$，空间复杂度为$O(N)$。
它的基本思想是对两个已经排好序的表（设为A和B）进行合并。因为A，B都是已经排好序的。所以将输出放到第三个表(设为C）时，一趟排序就可以完成。
核心思想就是递归，如果输入序列只有1个元素，答案很显然。否则，就对序列中的前半部分数据和后半部分数据各自进行归并排序。然后再把两个已经排好序的表合并到一块。
我下面给出归并排序的一个实现：

#include <iostream>
#include <memory>
#define N 10
template <typename T> class Sort{
    private:
        T Array[N]={99,12,121,34,1212,42421,234,123,1,896};
        int length=N;
    public:

        void Msort(T Array[],T TempArray[],int left,int right); 
        void MergeSort(T Array[],int len);
        void Merge(T Array[],T TempArray[],int Lpos,int Rpos,int Rightend);

        void call(){
            MergeSort(Array,length);
        }

        void print(){
            for(int i=0;i<N;i++)
                std::cout<<Array[i]<<"\t";
            std::cout<<std::endl;
        }
};
template <typename T> void Sort<T>::Msort(T Array[],T TempArray[],int left,int right){
    int Center;
    if(left<right){
        Center=(left+right)/2;
        Msort(Array,TempArray,left,Center);
        Msort(Array,TempArray,Center+1,right);

        Merge(Array,TempArray,left,Center+1,right);
    }
}
template <typename T> void Sort<T>::MergeSort(T Array[],int len){
    std::allocator<T> alloc;
    T *TempArray=alloc.allocate(N*sizeof(T));
    if(TempArray==nullptr)
        exit(0);

    Msort(Array,TempArray,0,len-1);

    free(TempArray);    
};

template <typename T> void Sort<T>::Merge(T Array[],T TempArray[],int Lpos,int Rpos,int RightEnd){
    int i,LeftEnd,NumElements,TemPos;
    LeftEnd=Rpos-1;
    TemPos=Lpos;
    NumElements=RightEnd-Lpos+1;

    //main loop
    while(Lpos<=LeftEnd && Rpos<=RightEnd){
        if(Array[Lpos]<=Array[Rpos])
            TempArray[TemPos++]=Array[Lpos++];
        else
            TempArray[TemPos++]=Array[Rpos++];
    }
    //剩余元素 
    while(Lpos<=LeftEnd)
        TempArray[TemPos++]=Array[Lpos++];
    while(Rpos<=RightEnd)
        TempArray[TemPos++]=Array[Rpos++];

    for(int i=0;i<NumElements;i++,RightEnd--)
        Array[RightEnd]=TempArray[RightEnd];

}
int main(void){
    Sort<int> A1;
    A1.call();
    A1.print();
    return 0;
}

下面介绍希尔排序：
希尔排序思想很简单，它是不是像普通的交换排序算法那样先比较相邻位置的元素，而是先比较间隔距离较远的元素，在比较距离较近的元素。被比较元素之间的距离逐渐减小，直到减少为1。这个时候就变成了相邻位置元素的互换。可以看作是每次对序列中的一个字数组进行排序。它的上界为$\Theta(\ n^2)$
下面给出一个简单的实现：

#include <cstdio>
void hill_sort(int array[]){
    int n=N,temp=0,gap=0,i,j;
    //C Programming Language
    for(gap=n/2;gap>0;gap/=2){
        for(i=gap;i<n;i++)
        for(j=i-gap;j>=0 &&array[j]>array[j+gap];j-=gap){
                      temp=array[j];
                      array[j]=array[gap+j];
                      array[gap+j]=temp;
        }
    }
}
int main(void){
    int array[N]={7,3,1,99,173,824,657,251,27723,89},print_array[N];    
    hill_sort(array);
    printf("希尔排序结果: \n");
for(int i=0;i<N;i++)
       printf("\t%d\n",array[i]);      
       return 0;
}

以上
参考书籍：C Programming Language.
     Data Structure And Algorithm Analysis In C