归并排序（默认2路归并）

以下是本人的看完下面这一视频后的心得体会，该文章内容大致分为:折半查找的核心以及视频的折半查找与408课本上的折半查找的区别.如果看不懂的地方可以先看下面这位大佬的【排序算法精华2】归并排序_哔哩哔哩_bilibili，再回过头来看该文章。若有错误的地方忘各位友友指出！！！🥳🥳🥳

1. 思想：与快排一样利用了分治法的思想，即将原问题分解成较小的子问题、分别解决子问题、最后合并子问题。
2. 思路：将原问题分解为m个子问题，将子问题进行排序，形成m个有序的子问题（相对有序），再将这m个有序的子问题在合并的过程中进行排序，最终合并成一个有序的原问题。（绝对有序）。
3. 由于使用的是分治法的思想，所以快排与归并排序十分相似，不同之处在于：快排将原问题分解成每个子问题，确定每个元素的绝对位置，最后无需合并，因为在一开始的问题中已经是有序的了；而归并排序每次将原问题分解成m个子问题（2路归并：每次分解成2个子问题），子问题在上一个原问题内是有序的，在一开始的问题里不一定是有序的，因此需要在合并的过程中，每次将m个子问题合并成一个原问题。

• 快排（用枢轴当分界线；初始化l和r为-1何N，左闭右闭）

• 归并排序（用mid对应的元素来当分界线；初始化l和r为0和N，左闭右开）

4. 整体伪代码

5. 时间复杂度分析

由于每层需要比较n个元素，递归的形式像树的结构，因此层数为logn，因此时间复杂度为O(nlogn)。

由于每层需要创建n个辅助数组，因此空间复杂度为O(n)。

由于归并排序是顺序排序的，非常适合链表的顺序访问。

对于链表来说，可以利用前后指针找到mid所在的位置分成两个链表，链表比较的过程中直接在原链表中改变指针即可，因为每次改变元素次序，就需要改变该元素后面的的次序，假如A中的元素其中一个比B的一个元素大，那么B中的元素插入到A中时，会导致A的元素整体往后移，因此不适用于数组，所以数组需要额外创建一个辅助数组来实现排序。所以链表的空间复杂度为O(1)。

6. 视频中的代码

//**************************************2路归并排序******************************************************//

//Merge函数将A分解为L和R数组，并且在L和R数组后添加一个无穷大元素，其作用是当其中一个数组已经在A中都排好序，剩下的无穷大比另一个数组中的任何一个元素都大，可以保证另一个元素都复制到A中。//
void Merge(int A[], int l, int mid, int r){
    int temp_l = l;
    //将大数组赋值给子问题数组
    int L[mid - l + 1];       
    int i;          
    for(i = 0; i < mid - l; i++)L[i] = A[temp_l++];     //L = A[l..mid - 1].copy()
    L[i] = INT_MAX;                                     //L.append(+∞)充当哨兵

    int R[r - mid + 1];
    int j;
    for(j = 0; j < r - mid; j++)R[j] = A[temp_l++];     //R = A[mid..r - 1].copy()
    R[j] = INT_MAX;                                     //R.append(+∞)

    //比较后合并
    int k = l;                                          //遍历大数组
    i = 0,j = 0;
    while(k != r){
        //比较大小
        if(L[i] <= R[j])A[k++] = L[i++];
        else A[k++] = R[j++];
    }
}

//将数组A中[l,r)的左闭右开区间的元素进行排序
void MergeSort(int A[], int l, int r){      //初始化l = 0，r = N
    if(r - 1 <= l)return;
    int mid = (l + r) / 2;                  //获得分割处
    //开始分治，分为左右两子问题
    MergeSort(A, l, mid);                   //由于是左闭右开，所以这里的r应该等于mid
    MergeSort(A, mid, r);                   //同理，因为左闭右开，左闭为mid，右开为r
    //合并
    Merge(A, l, mid, r);
}
//**************************************2路归并排序******************************************************//

7. 408教材中的代码，与上述视频中的代码不同在于

• 初始化不同：408教材初始化low = 0, high = n - 1，而视频初始化low = 0, high = n，即一个是左闭右闭，一个是左闭右开。
• 数组创建不同：408教材创建一个与A一样大的辅助数组，而视频创建两个数组。
• 有无哨兵：408教材通过判断辅助数组遍历的位置来判断第一个表或者第二个表是否检测完；而视频则是通过+∞使得剩余没复制完的元素复制到A上。

//**************************************教材2路归并排序******************************************************//

void Merge(int A[], int low, int mid, int high){
    int *B = (int*)malloc((high - low + 1) * sizeof(int));      //辅助数组B
    //表A的两端A[low...mid]和A[mid+1...high]各自有序，将他们合并一个有序表
    int i,j,k;
    for(k = low; k <= high; k++)
        B[k] = A[k];                //将A中所有元素赋值到B中
    // Print(A);
    for(i = low, j = mid + 1, k = i; i <= mid &&j <= high; k++){
        if(B[i] <= B[j])A[k] = B[i++];      //比较B的左右两段中的元素,将较小值赋值到A中
        else A[k] = B[j++];
    }
    while(i <= mid)A[k++] = B[i++];             //若第一个表未检测完，复制
    while(j <= high)A[k++] = B[j++];            //若第二个表未检测完，复制
}

//将数组A中[low,high]的左闭右闭区间的元素进行排序
void MergeSort(int A[], int low, int high){      //初始化l = 0，r = N - 1
    if(low < high){
        int mid = (low + high) / 2;             //从中间划分两个子序列
        MergeSort(A, low, mid);                 //对左侧子序列进行递归排序
        MergeSort(A, mid + 1, high);            //对右侧子序列进行递归排序
        Merge(A, low, mid, high);               //归并
    }
}

//**************************************教材2路归并排序******************************************************//