菜鸟学习历程【15-6】堆排序、归并排序、基数排序

堆排序

堆排序是将序列人为的类比做堆来处理，分为大堆和小堆，大堆就是双亲结点大于孩子结点，这里的孩子自身可能也是“双亲”，那么这个“双亲”还要大于它的孩子，小堆于此相反。
当所有结点满足这个大堆的条件后，最上面的根节点肯定是这个序列中最大的数，然后我们将这个数与最后一个结点交换，再对除了最后一个结点外的所有结点进行大堆处理，依次反复，最终会将这个序列排成从小到大的顺序。

下面，让我们结合图来详细的说明：
以序列a[] = {29, 17, 35, 6, 12, 31, 28, 15}为例；
整个遍历的过程是从最后一个非叶子节点开始，依次将所有非叶子结点遍历完成；

首先将序列按照顺序排成二叉树的模样：

这里我们需要知道几个知识点：
1.最后一个非叶子结点的下标为：length / 2 - 1 ;
2.假设根节点的下标为i，其左孩子的下标为2 * i + 1，右孩子的下标为2 * i + 2;

第一次遍历：
6是最后一个非叶子节点，比较其与孩子结点的大小，发现6<15，于是交换两者的内容，并将15作为双亲，继续与它的孩子进行比较，但15并没有孩子，于是第一次遍历结束，结果如下图；

第二次遍历：
35是倒数第二个非叶子结点，比较其与孩子结点的大小，35大于它所有的孩子结点，所以不进行交换，本次遍历结束；

第三次遍历：
17是倒数第三个非叶子结点，比较其与孩子结点的大小，17大于它所有的孩子结点，所以不进行交换，本次遍历结束；

第四次遍历：
29是倒数第四个非叶子结点，比较其与孩子结点的大小，发现29<35，于是交换二者内容（此时35在下标为0的位置，29在下标为2的位置）

之后，再将29作为双亲与它的孩子结点比较大小，发现29 < 31，于是交换二者内容（此时31在下标为2的位置，29在下标为5的位置）

最后，将29与其孩子结点进行比较，并没有孩子结点，本次遍历结束。
通过这四次遍历，这个二叉树已经满足大堆的要求，并且最大数35在最上面，对应于下标0的位置。于是将35与最后一个结点交换内容，（此时35的下标为7）并对除去35以外的所有结点再次执行大堆操作。

---

新一轮遍历

第一次遍历：
31作为最后一非叶子结点，与其孩子进行比较，并没有比它大的孩子，于是本次遍历结束；

第二次遍历：
17是倒数第二个非叶子结点，比较其与孩子结点，并没有比它大的孩子结点，于是本次遍历结束；

第三次遍历：
将6与其孩子结点比较大小，并且最大的孩子结点是31，所以将31与6进行交换（此时，31在下标为0的位置，6在下标为2的位置）

将6再与孩子结点进行比较，将最大孩子结点与其交换内容（此时，29在下标为2的位置，6在下标为5的位置）

再次将6与其孩子结点进行比较，并不存在孩子结点，所以本次遍历结束；
通过这三次遍历，这个二叉树已经满足大堆的要求，并且最大数31在最上面，对应于下标0的位置。于是将31与最后一个结点交换内容，（此时31的下标为6）并对除去31以外的所有结点再次执行大堆操作。

---

新一轮遍历：

第一次遍历：
29是最后一个非叶子结点，比较其与孩子结点的大小，并没有比它大的孩子结点，此次遍历结束；

第二次遍历：
17是倒数第二个非叶子结点，比较其与孩子结点的大小，并没有比它大的孩子结点，此次遍历结束；

第三次遍历：
28与其叶子结点比较大小，发现29>28，于是交换二者内容（此时29在下标为0的位置，28在下标为2的位置）

将28与其孩子结点比较大小，并没有大于它的孩子结点，于是本次遍历结束；
通过这三次遍历，将最大数29移到下标为0的位置，于是将 29与最后一个结点交换内容，即6在下标为0的位置，29在下标为5的位置，再对除去29以外的所有数进行大堆操作；

之后的过程以前面相同，就不再赘述。

下面附上代码：

#include <stdio.h>

void Swap(int *a, int *b)
{
    int tmp;
    tmp = *a;
    *a = *b;
    *b = tmp;
}

void Adjust(int array[], int parent, int len)  //大堆操作，调整二叉树满足所有双亲结点大于其孩子结点
{
    int child;
    child = 2 * parent + 1;
    while(child < len)
    {       //如果存在右孩子，并且右孩子大于左孩子，则将右孩子与双亲进行比较
        if((child + 1) < len && array[child] < array[child + 1])
        {
            child++;
        }
        if(array[child] > array[parent])              //如果孩子大于双亲，则交换二者内容
        {
            Swap(&array[child], &array[parent]);
            parent = child;
            child = 2 * parent + 1;
        }
        else
        {
            break;
        }
    }
}

void BigHeapSort(int arr[], int len)
{
    int i, length;
    for(i = len / 2 - 1; i >= 0; i--)
    {
        Adjust(arr, i, len);
    }
    length = len - 1;
    while(length > 0)       //将最大数与最后一个结点内容交换，并对除去最大数以外的所有数再次进行大堆处理
    {
        Swap(&arr[0], &arr[length]);
        Adjust(arr, 0, length);
        length--;
    }
}

int main()
{
    int i, length;
    int a[] = {29, 17, 35, 6, 12, 31, 28, 15};

    length = sizeof(a) / sizeof(a[0]);
    BigHeapSort(a, length);

    for(i = 0; i < length; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
    return 0;
}

---

归并排序

利用递归与分治技术将数据序列划分为越来越小的半子表，再对半子表排序，最后再用递归步骤将排好序的半子表合并成为越来越大的有序序列。

原理如下：对于给定的一组记录，首先将两个相邻的长度为1的子序列进行归并，得到n/2个长度为2或者1的有序子序列，在将其两两归并，反复执行此过程，直到得到一个有序的序列为止。

具体如何实现，结合图片详解：
以序列a[] = {29, 17, 35, 6, 12, 31, 28, 15}为例；

第一步、我们将这个序列拆分成最小单元，也就是一个个的数据。

第二步、将半子表一一合并成有序的序列，那么在合并的过程中，就涉及到了排序。我们以左边为例进行说明。

首先对29与17进行比较，将较小数17放在数组tmp中（此处及之后的说明中，都将合并后的数存放在数组tmp中），大数29放在后面，35与6的情况一样。那么排序后结果如下图：

其次，将（17， 29）与（6， 35）进行比较，两个数组分别用 i 和 j 表示下标。先比较下标0的数值，将小数6放在数组tmp的最前面，此时将 j 指向1， i 依旧指向0；

接着，比较下标 i 与下标 j 对应的数值。注意，此时 i 依旧指向0，即比较17与35，发现17小于35，于是把17写在6的后面，此时 i 指向下标1，j 还指向下标1；

此时，比较29与35，将小数29写在17后面，循环结束，但还剩余一个数35，于是最后将35写到数组tmp的最后，左边所有归并就完成了。

下面附上代码：

#include <stdio.h>
#include <stdlib.h>

void Merge(int array[], int start, int middle, int end)
{
    int i, j, k, n1, n2;

    n1 = middle - start + 1;          //前半部分序列长度    
    n2 = end - middle;                //后半部分序列长度 

    int *L = (int *)malloc(n1 * sizeof(int));  //前半部分临时数组
    int *R = (int *)malloc(n2 * sizeof(int));  //后半部分临时数组

    for (i = 0, k = start; i < n1; i++, k++)   //将原序列的前半部分复制到临时数组中
    {
        L[i] = array[k];
    }

    for (i = 0, k = middle + 1; i < n2; i++, k++)  //将后序列的前半部分复制到临时数组中
    {
        R[i] = array[k];
    }

    // 先比较对应位置的数值，将最小值（假设是下标L[0]）写入原序列后，i 变成 1
    // 继续比较下标L[1]与R[0]，如果L[1] < R[0],继续将L[1]写入原序列，i变成2
    //i不再满足循环条件（假设本次左半部分长度为2），循环结束，但R数组中还有两个数未写入
    //那么，就将这两个数按顺序写入序列
    for (k = start, i = 0, j = 0; i < n1 && j < n2; k++)
    {
        if (L[i] < R[j])        
        {
            array[k] = L[i];
            i++;
        }
        else
        {
            array[k] = R[j];
            j++;
        }
    }

    if (i < n1)        //如果L数组中还有剩余的数，则按顺序写入原数组中
    {
        for (j = i; j < n1; j++, k++)
        {
            array[k] = L[j];
        }
    }

    if (j < n2)        //如果R数组中还有剩余的数，则按顺序写入原数组中
    {
        for (i = j; i < n2; i++, k++)
        {
            array[k] = R[i];
        }
    }

    free(L);
    free(R);

}

void MergeSort(int array[], int start, int end)
{
    int middle;
    int i;

    if (start < end)
    {
        middle = (start + end) / 2;  //将序列一分为二

        MergeSort(array, start, middle);  //左半部分，递归继续拆分，直到单个
        MergeSort(array, middle + 1, end);  //右半部分，递归继续拆分，直到单个
        Merge(array, start, middle, end);   //待整个序列全部拆分完毕后，从最低层开始排序合并
    }
}

int main()
{
    int i = 0;
    int a[] = {29, 17, 35, 6, 12, 31, 28, 15};
    int length = sizeof(a) / sizeof(a[0]);

    MergeSort(a, 0, length -1);

    for (i = 0 ; i < length; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");

    return 0;
}

---

基数排序

基数排序：是一种借助多关键字排序的思想对单逻辑关键字进行关系的方法。基数排序不需要进行记录关键字间的比较。

主要有两个过程：
1）分配，先从个位开始，根据位值(0-9)分别放到0~9号桶中（比如53,个位为3，则放入3号桶中）

2）收集，再将放置在0~9号桶中的数据按顺序放到数组中

我想，大多数人看到上述的解释，对什么是基数排序并不会有太深的理解，那么下面结合图片进行分析讲解；

首先，什么叫做 借助多个 关键字 排序，对于 整型序列 而言，我们将这样的 多关键字 理解为 数位（个位，十位，百位，千位。。。），也就是说对 整型序列 通过数位 进行排序，那么到底怎么排的呢？

以序列 int a[] = {229, 17, 35, 6, 12, 31, 28, 102} 为例；

我们知道 每个 数位 都是 0 ~ 9，第一次 按照 个位的顺序 进行排序

那么，第二次 我们按照 十位 的顺序进行排序

接着，第三次 我们按照 百位 的顺序进行排序

因为，序列中 最大数 也只有百位，所以排序 排到这里 就已经结束了，最终结果也显而易见。

附上代码，对一些语句会进行说明：

#include <stdio.h> 

#include <stdlib.h>

void RadixCountSort(int *index,int *a,int len)  
{  
    int i;  
    int *count=(int *)malloc(sizeof(int)*10);  

    for(i=0;i<10;i++)  // 清空桶
    {  
        count[i]=0;  
    }  

    for(i=0;i<len;i++)  // 对应桶内 存放 数的个数; 对应的数位 是多少 就在 对应的 桶 位置 + 1，比如 个位 为 3，就填到 3 的位置
    {  
        //index[i] 表示 原序列中第 i 个数 的对应数位 的值，例如，第一次,求 个位 时，index[0] = 0,那么在 count[0]的值就 + 1
        count[index[i]] ++;  
    }  

    for(i=1;i<10;i++)  // 前面的个数 == 下标加 1 
    {  
        count[i]=count[i] + count[i - 1]; 
    }  

    int *sort=(int *)malloc(sizeof(int)*len);  

    for(i=len-1;i>=0;i--)  
    {  
        count[index[i]] --;  // 计算下标 ， 最终结果是 下标 + 1，所以要减去 1 才是真正的下标

        sort[count[index[i]]] = a[i];  // 将原序列 重新排序
    }  

    for(i=0;i<len;i++)  
    {  
        a[i]=sort[i];  
    }  

    free(sort);  
    free(count);  
}  

void RadixSort(int *a,int len)  
{  
    int i , x=1;  
    int tmp=1;  
    int *radix=(int *)malloc(sizeof(int)*len);  // radix 保存 每一轮对应数位 的值

    while(x)  
    {  
        tmp=tmp * 10; 
        x=0;  

        for(i=0;i<len;i++)  
        {  
            radix[i]=a[i] % tmp;   //　例如:当 tmp = 100 时，求出十位 和 个位 的数， 121 % 100 = 21
            radix[i]=radix[i] / (tmp / 10);  // 21 / (100 / 10) = 2;
            if(a[i] / tmp > 0)  
            {  
                x = 1;  // 判断是否需要 下一轮 循环
            }  
        }  
        RadixCountSort(radix,a,len);  // 每一轮求出 对应数位的值 以后 重新排序
    }  
    free(radix);  
}  

int main()
{
    int i;
    int len;
    int a[]={100, 8 , 1099, 6, 1, 300, 405, 604, 102, 806, 706, 504}; 
    len=sizeof(a)/sizeof(a[0]);
    RadixSort(a,len);
    for(i=0;i<len;i++)  
    {  
        printf("%d \n",a[i]);  
    }   
    return 0;
}

---

八种排序的比较

排序方法	最好时间	平均时间	最坏时间	辅助存储	稳定性
选择排序	O（n^2）	O（n^2）	O（n^2）	O（1）	不稳定
插入排序	O（n）	O（n^2）	O（n^2）	O（1）	稳定
冒泡排序	O（n）	O（n^2）	O（n^2）	O（1）	稳定
希尔排序	O（n^1.3）	O（nlogn）	O（n^2）	O（1）	不稳定
快速排序	O（nlogn）	O（nlogn）	O（n^2）	O（logn）	不稳定
堆排序	O（nlogn）	O（nlogn）	O（nlogn）	O（1）	不稳定
归并排序	O（nlogn）	O（nlogn）	O（nlogn）	O（kn）	稳定
基数排序	O（kn）	O（kn）	O（kn）	O（n）	稳定