进阶级排序算法

希尔排序：

void ShellSort(int array[], int len)// O(n*n)//希尔排序关键思想先分组，再分别插入排序
{
    int i = 0;
    int j = 0;
    int k = -1;
    int temp = -1;
    int gap = len;//用间隔量gap分组
    
    do
    {
        gap = gap / 3 + 1; //gap如何变化无严格要求，但要求经过若干次计算后，最后结果必须收敛于1，这样写是科学家总结出来最好的写法
    
        for(i=gap; i<len; i+=gap)//gap相当于插入排序算法中的第一个元素
        {
            k = i;
            temp = array[k];
            
            for(j=i-gap; (j>=0) && (array[j]>temp); j-=gap)
            {
                array[j+gap] = array[j];
                k = j;
            }
        
            array[k] = temp;
        }
        
    }while( gap > 1 );//循环条件，当gap=1时，恢复至插入排序
    
}//选gap的方式现在仍然是计算机界一个大问题，目前的选择都是根据大量工程实践而来

快速排序：

int partition(int array[], int low, int high)//一次划分函数
{
    int pv = array[low];//pv表示基准量
    
    while( low < high )
    {
        while( (low < high) && (array[high] >= pv) )//从高端开始比较
        {
            high--;
        }
        
        swap(array, low, high);//当high小于基准时，交换位置
        
        while( (low < high) && (array[low] <= pv) )
        {
            low++;
        }
        
        swap(array, low, high);//当low大于基准时，交换位置
    }
    
    return low;//基准量
}


void QSort(int array[], int low, int high)//快速递归划分
{
    if( low < high )
    {
        int pivot = partition(array, low, high);//
        
        QSort(array, low, pivot-1);
        QSort(array, pivot+1, high);
    }
}


void QuickSort(int array[], int len) // O(n*logn)//快速排序
{
    QSort(array, 0, len-1);
}

归并排序：

将两个或两个以上的有序序列合并成一个新的有序序列：
有序序列V[1] …V[m]和V[m+1] …V[n] V[1] …V[n]
这种归并方法称为2路归并。

将3个有序序列归并为一个新的有序 序列，称为 3路归并 。
将多个有序序列归并为一个新的有序序列， 称为 称为多路归并。

void Merge(int src[], int des[], int low, int mid, int high)//二路归并函数，source，destination
{
    int i = low;
    int j = mid + 1;
    int k = low;
    
    while( (i <= mid) && (j <= high) )
    {
        if( src[i] < src[j] )
        {
            des[k++] = src[i++];
        }
        else
        {
            des[k++] = src[j++];
        }
    }
    
    while( i <= mid )
    {
        des[k++] = src[i++];
    }
    
    while( j <= high )
    {
        des[k++] = src[j++];
    }
}


void MSort(int src[], int des[], int low, int high, int max)//将src里面的元素排序好之后，再将des中的值复制到src中
{
    if( low == high )//划分至只有一个元素，结束点
    {
        des[low] = src[low];
    }
    else
    {
        int mid = (low + high) / 2;//划分了两路
        int* space = (int*)malloc(sizeof(int) * max);//申请辅助空间
        
        if( space != NULL )
        {
            MSort(src, space, low, mid, max);//第一步，递归划分，将src中的部分内容进行归并排序调用，low到mid中的元素已经排好
            MSort(src, space, mid+1, high, max);//第二步，递归划分至结束，同上，mid+1到high中的元素也已经排好
            Merge(space, des, low, mid, high);//第三步，将low到mid中的元素merge（）至des中
        }
        
        free(space);//释放辅助空间
    }
}


void MergeSort(int array[], int len) // O(n*logn)
{
    MSort(array, array, 0, len-1, len);//将array中内容归并排序后再给到array中
}

希尔排序， 快速排序和归并排序将排序算法的时间复杂度提高到了O(n  * log n) ；

希尔排序和快速排序的排序结果是不稳定的，归并排序的排序结果是稳定的；

归并排序需要利用辅助空间，可直接做外排序！！