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

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];        }    }}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;}