希尔排序 ， 快速排序 ， 归并排序

希尔排序 ShellSort

当增量d=1时，已经排好序了，不需要继续循环。

#include <stdio.h>

void println(int array[], int len)
//打印数组 
{
    int i = 0;
    for(i=0; i<len; i++)
    {
        printf("%d ", array[i]);
    }   
    printf("\n");
}

void ShellSort(int array[], int len) // O(n*log(n))
//希尔排序 
{
    int i = 0;
    int j = 0;
    int k = -1;
    int temp = -1;
    int gap = len; //分组间隔 

    do
    {
        gap = gap / 3 + 1; 
        //gap的写法最终必须为1，gap=1时相当于插入排序
        //对每个组的元素进行插入排序 
        for(i=gap; i<len; i+=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 );   
}

int main()
{
    int array[] = {21, 25, 49, 25, 16, 8};
    int len = sizeof(array) / sizeof(*array); 

    println(array, len);  
    ShellSort(array, len);  
    println(array, len);

    return 0;
}

gap = gap / 3 + 1; 中的3，并不是因为要分为3个组的元素，而是这样写的平均效率高。如果写成gap = gap / 5 + 1; 也可以。但是，gap的最终结果必须为1。

希尔排序时间复杂度为O(n*logn)，但是不稳定。

快速排序 QuickSort

首先对无序的记录序列进行“一次划分”，之后分别对分割所得两个子序列“递归”进行快速排序。

代码编写：

#include <stdio.h>

void println(int array[], int len)
//打印数组 
{
    int i = 0;   
    for(i=0; i<len; i++)
    {
        printf("%d ", array[i]);
    }   
    printf("\n");
}

void swap(int array[], int i, int j)
//交换两个元素 
{
    int temp = array[i];   
    array[i] = array[j];    
    array[j] = temp;
}

int partition(int array[], int low, int high)
//划分的过程，low为最左端，high为最右端 
//以第一个元素为基准，左侧为小于它的元素，右侧为大于它的元素 
{
    int pv = array[low];

    while( low < high )
    {
        while( (low < high) && (array[high] >= pv))
        //判断右侧元素是否比第一个元素大 
        {
            high--;
        }

        swap(array, low, high);

        while( (low < high) && (array[low] <= pv))
        //判断左侧元素是否比第一个元素小 
        {
            low++;
        }

        swap(array, low, high);
    }
    //返回基准元素的位置    
    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);
}

int main()
{
    int array[] = {21, 25, 49, 25, 16, 8};
    int len = sizeof(array) / sizeof(*array); 

    println(array, len);  
    QuickSort(array, len);   
    println(array, len);

    return 0;
}

经过数学证明，快速排序时间复杂度为O(n*logn)，但是不稳定。

归并排序 MergeSort

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

检测两个有序序列A和B，C为归并后的新的有序序列：
当 i和 j都在两个序列内变化时, 根据关键码的大小将较小的数据元素排放到新序列 k所指位置中.
当 i 与 j 中有一个已经超出序列时，将另一 个序列中的剩余部分照抄到新序列中.

代码编写：

#include <stdio.h>
#include <malloc.h>

void println(int array[], int len)
//打印数组 
{
    int i = 0; 
    for(i=0; i<len; i++)
    {
        printf("%d ", array[i]);
    }   
    printf("\n");
}

void swap(int array[], int i, int j)
//交换数组元素 
{
    int temp = array[i];  
    array[i] = array[j];  
    array[j] = temp;
}

void Merge(int src[], int des[], int low, int mid, int high)
//本函数实现对src数组中两部分元素的归并排序，赋值给des数组 
//将src数组由mid下标分成两部分，归并到des数组中 
{
    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中 
    {
        des[k++] = src[i++];
    }

    while( j <= high )//将剩余的元素复制到des中 
    {
        des[k++] = src[j++];
    }
}

void MSort(int src[], int des[], int low, int high, int max)
//将src中的元素进行排序，然后将排好序的元素赋值给des数组 
//low和high分别为数组最左端和最右端下标，max为数组长度 
{
    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前部分归并到space 
            MSort(src, space, mid+1, high, max);//将src后部分归并到space 
            Merge(space, des, low, mid, high);//将space中的元素归并到des 
        }

        free(space);
    }
}

void MergeSort(int array[], int len) // O(n*logn)
//归并排序算法 
{
    MSort(array, array, 0, len-1, len);
}

int main()
{
    int array[] = {21, 25, 49, 25, 16, 8};
    int len = sizeof(array) / sizeof(*array); 

    println(array, len);   
    MergeSort(array, len);
    println(array, len);

    return 0;
}

小结

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

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

口诀：
选快希堆不稳（是不稳定的排序），
堆归选基不变（运行时间不发生变化，与初始状态无关）
基数排序 堆排序