图解算法系列之归并排序

Posted 2021-01-28

（1）算法描述

对于给定的线性序列，将当前序列不断的进行分组，当每个分组的数据只有一个元素时，代表这个分组是有序的，那么向上合并。每一层两两合并，合并的过程是，开辟一个新空间，使用两个指针同时扫描两个有序的分组，使得较小的元素或者较大的元素先进入新空间。在不断的比较之后，如果一个分组的元素为空，直接拷贝另一个没有被用完的元素到新空间。

（2） 图解算法

归并排序的过程

合并函数的合并过程

（3） C/C++代码实现

CustomSort.h

// 归并排序
void MergeSort(int arr[], int number);
// 内部的归并排序
void __MergeSort(int arr[], int left, int right);
// 内部合并
void __Merge(int arr[], int left, int mid, int right);

CustomSort.cpp

/************************************************************
- 功能描述：实现归并排序
- int arr[]: 待排序的数组
- int number: 待排序数组中的元素
- 返回值：void
************************************************************/
void MergeSort(int arr[], int number) {
    // 数组为空或者有一个一下的元素直接返回
    if(arr == NULL || number <= 1) {
        return;
    }

    // 调用内部排序算法
    __MergeSort(arr, 0, number-1);
}

/************************************************************
- 功能描述：实现归并排序的内部排序
- int arr[]: 待排序的数组
- int left: 待排序数组的左边界
- int right: 待排序数组的右边界
- 返回值：void
************************************************************/
void __MergeSort(int arr[], int left, int right) {
    // 如果 right <= left 没有排序的必要性
    if(right <= left) {
        return;
    }

    // 计算中间值
    // 没有使用 (right + left) / 2 是为了避免数据太大导致内存溢出
    int mid = (right - left) / 2 + left;

    // 分别排序两个分组
    __MergeSort(arr, left, mid);
    __MergeSort(arr, mid+1, right);

    // 排序完成后就合并两个分组
    __Merge(arr, left, mid, right);
}

/************************************************************
- 功能描述：实现归并排序的分组合并
- int arr[]: 待排序的数组
- int left: 待合并数组的左边界
- int right: 待合并数组的右边界
- int mid: 待合并数组的中间值
- 返回值：void
************************************************************/
void __Merge(int arr[], int left, int mid, int right) {
    int len = right - left + 1;

    // 动态创建数组，因为每个分组的大小都不一样，使用完需要delete[]空间
    int *temp = new int[len];

    // 用于第一个分组的指针one
    // 用于第二个分组的指针two
    // 用于辅助数组的指针i
    int one = left;
    int two = mid + 1;
    int i = 0;

    // 判断只要one和two都没有越界就不断的进行比较
    while(one <= mid && two <= right) {
        temp[i++] = arr[one] > arr[two] ? arr[one++] : arr[two++];
    }

    // 判断哪个数组的指针还没到头就直接全都拷贝到temp数组
    while(one <= mid) {
        temp[i++] = arr[one++];
    }
    while(two <= right) {
        temp[i++] = arr[two++];
    }

    // 往回拷贝数组，注意数组的位置
    for(int j = 0; j < len; j++) {
        arr[left + j] = temp[j];
    }

    delete[] temp;
}

（4） Java代码实现

public class MergeSort {
    // 归并排序函数
    public static void sort(int[] arr) {
         // 如果数组为null或者是数组中的元素小于2, 没有排序的意义
         if (arr == null || arr.length < 2) {
               // 直接返回
               return;
         }
         // 调用排序函数
         mergeSort(arr, 0, arr.length - 1);
    }
    // 主要逻辑
    public static void mergeSort(int[] arr, int l, int r) {
         // 如果左边的指针等于右边指针, 也就是数组不能再分割
         if (l == r) {
               // 就要直接返回
               return;
         }
         // 数组中间数值的指针位置
         int mid = l + ((r - l) >> 1);
         // 排序中间位置左边的数组
         mergeSort(arr, l, mid);
         // 排序中间位置右边的数组
         mergeSort(arr, mid + 1, r);
         // 合并函数
         merge(arr, l, mid, r);
    }
     // 合并函数
    public static void merge(int[] arr, int l, int m, int r) {
         // 创建辅助数组
         int[] help = new int[r - l + 1];
         // 辅助数组的指针位置
         int i = 0;      
         // 数组1的指针位置
         int p1 = l;
         // 数组2的指针位置
         int p2 = m + 1;
         //  判断左边和右边的数组是否越界
         while (p1 <= m && p2 <= r) {
               // 如果都没有越界, 向辅助数组添加数据，类似于外排的方式
               help[i++] = arr[p1] < arr[p2] ? arr[p1++] :  arr[p2++];
         }
         // 如果第一个数组的指针还没到头, 就要拷贝数组
         while (p1 <= m) {
               help[i++] = arr[p1++];
         }
         // 如果第二个数组的指针还没到头, 就要拷贝数组
         while (p2 <= r) {
               help[i++] = arr[p2++];
         }
         // 拷贝排序后数组
         for (i = 0; i < help.length; i++) {
               arr[l + i] = help[i];
         }
    }
}

（5） 时间复杂度分析

当函数出现递归调用的时候，一个函数A调用了本身，假定是subA，那么当前的函数A将会压入系统的栈内，系统将会保存现场（包括函数执行到哪一行代码，函数当前的调用状态以及函数中变量的值），进行下一个函数的执行，经过一层层函数的调用，遇到一个返回条件，系统中的栈中保存的状态将会一个一个的弹出，也就是函数的恢复现场，最后函数调用结束。
只要符合master公式的都可以使用一下方法计算时间复杂度：
master公式：T(N)=a*T(N/b)+O(Nd)

1) log(b, a) > d 复杂度是O(N log(b,a))
2) log(b, a) = d 复杂度是O(Nd * log(2, N))
3) log(b, a) < d 复杂度是O(Nd)

估计时间复杂度：左侧部分的规模和右侧部分的规模都是N/2，在整体外排的过程中总共划过N个数，算式为：T(N)=2T(N/2)+O(N)，代入master公式，复杂度就是O(N*log2N)，空间复杂度是O(N)。