经典算法（五）---归并排序

一、并归排序

1. 归并排序的定义

归并排序（Merge Sort）是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法（Divide and Conquer）和递归（Recursion）思想的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

算法描述：   

归并操作的工作原理如下：

• 第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
• 第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置
• 第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
• 重复步骤3直到某一指针超出序列尾
• 将另一序列剩下的所有元素直接复制到合并序列

算法思想：

1. 将待排序序列不断二分，直到每个子序列只有一个元素为止。
2. 将相邻的子序列进行比较并合并，合并后的序列仍然是有序的。
3. 重复步骤2，直到所有子序列合并成一个完整的序列

算法分析：

简单理解：归并排序分两大步，第一步分，第二步合。

归并排序第一步：分

分采取一分为二的方法（所以这个归并排序又叫二路归并排序）

中间下标 mid=(first+last)/2（first是最左边，last是最右边），采取前面的公式，分为【first,mid】和【mid+1,last】两份

如下图所示的：

mid = (0 + 8) / 2 = 4,中间的下标为4，所以第一次划分就为【9 5 2 7 17】【first,mid】和【4 3 1 11】【mid+1,last】这两份，然后继续分mid = (0 + 4) / 2 = 2 （mid=(first+last)/2）中间的下标为2，所以分为【9 5 2】和 【7 12】两份，以此类推分到每一份只有一个元素。

---

归并排序第二步：合

在合成过程中需要一个临时数组来存合成的结果。可以定义两个变量 l_pos和 r_pos分别标记两个数组的第一个元素，比较他俩谁小。较小的那个元素放到临时数组里面，指向数组的变量后移。只要其中一个变量走到头位置，这时候就需要把另一个数组剩余的元素放到临时数组里面。

（因为两份序列都是已经有序的，一个序列走到头，就相当与最大的一个数也没有 另一个没有走到头的序列最前面的数字大，所以这时候就能直接拷贝剩下的元素排在临时数组的后面）

如下图所示的：

从下图的合并开始看

9 和 5 比较, 5 < 9 ,组成一个子序列【5 9】，继续和【2】比，【5 9】这个子序列的第一个元素和【2】子序列的第一个元素比较并存入临时数组为：【2 5 9】；

7 和 12 比较,7 < 12 ,组成一个子序列【7 12】，然后【2 5 9】和【7 12】进行比较并存入临时数组为：【2 5 7 9 12】

过程为：（2和7比，2小存入【2】，然后指针后移指向5, 5和7比，5小，5存入变为【2 5】，然后指针后移指向9，7比9小，7存入【2 5 7】，第二子序列指针后移指向12, 然后9和12比，9小于12,9存入【2 5 7 9 】，第一序列已经走完了，说明第二子序列剩下的每一个都会比第一子序列最后一个元素9大，所以12存入临时数组为【2 5 7 9 12】

---

流程图如下所示：

该算法采用经典的分治（divide-and-conquer）策略，分：问题分成一些小的问题然后递归（Recursion）求解，治：将分的阶段得到的各答案"修补"在一起，即分而治之。将序列递归拆分成多个子序列，再将各个子序列排序后归并叠加，最后归并所有子序列，排序完成。

参考代码：

#include <stdio.h>
#include <stdlib.h>
//复制函数：打印数组
void print_arr(int arr[], int n)
{
    for (int i = 0; i < n; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

// 合并
void merge(int arr[], int tempArr[], int left, int mid, int right)
{
    // 标记左半区第一个未排序的元素
    int l_pos = left;
    // 标记右半区第一个未排序的元素
    int r_pos = mid + 1;
    // 临时数组元素的下标
    int pos = left;

    // 合并
    while (l_pos <= mid && r_pos <= right)
    {
        if (arr[l_pos] < arr[r_pos])  // 左半区第一个剩余元素更小
            tempArr[pos++] = arr[l_pos++];
        else  // 右半区第一个剩余元素更小
            tempArr[pos++] = arr[r_pos++];
    }

    // 合并左半区剩余的元素
    while (l_pos <= mid)
        tempArr[pos++] = arr[l_pos++];

    // 合并右半区剩余的元素
    while (r_pos <= right)
        tempArr[pos++] = arr[r_pos++];

    // 把临时数组中合并后的元素复制回原来的数组
    while (left <= right)
    {
        arr[left] = tempArr[left];
        left++;
    }
}

// 归并排序
void msort(int arr[], int tempArr[], int left, int right)
{
    // 如果只有一个元素，那么不需要继续划分
    // 只有一个元素的区域，本生就是有序的，只需要被归并即可
    if (left < right)
    {
        // 找中间点
        int mid = (left + right) / 2;
        // 递归划分左半区
        msort(arr, tempArr, left, mid);
        // 递归划分右半区
        msort(arr, tempArr, mid + 1, right);
        // 合并已经排序的部分
        merge(arr, tempArr, left, mid, right);
    }
}

// 归并排序入口
void merge_sort(int arr[], int n)
{
    // 分配一个辅助数组
    int tempArr[n];
    // 调用实际的归并排序
    msort(arr, tempArr, 0, n - 1);
}

int main(int argc, char const* argv[])
{
    int arr[] = { 9, 5, 2, 7, 12, 4, 3, 1, 11};
        int n = 9;//要排序的数组元素个数
        print_arr(arr, n);

        merge_sort(arr, n);
        print_arr(arr, n);
    
    return 0;
}