归并(Merge)排序

前言

本篇文章记录了Python与C++的归并排序实现与讲解

以下是本篇文章正文内容，下面案例可供参考

一、什么是归并排序？

归并：把两个或多个已经有序的序列合并成一个序列。
2路归并：把2个有序序列合并成一个序列。
2路归并每选出一个元素需要对比1次关键字。
所以m路归并，每选出一个元素需要对比关键字m-1次。

二、算法思想

1. 将一个无序的序列，建立一个指向表头的low指针，一个指向表尾的hight指针，mid=(low+hight)/2指针将序列从中间分开。
2. 对左半部分[low,mid]递归的进行归并排序
3. 对右半部分[mid+1,hight]递归的进行归并排序
4. 将左右两个有序子序列Merge为一个有序序列。

三、动态演示

四、代码示例

4.1.C++代码示例

int n=10;										
int *B=(int *)malloc(n*sizeof(int));					// 建立一个辅助数组

//A[low..mid]和A[mid+1,hight]各自有序，将两个部分归并
void Merge(int A[],int low,int mid ,int hight){
	/************************************************* 
	Function:       // Merge
	Description:    // 合并，将多个有序序列合并成为一个
	Calls:          // None;
	Input:          // A[]-被排序数组  low-表头index,hight-表尾index，mid-切分成2个表
	Output:         // None
	Return:         // None 
	*************************************************/  
    int i,j,k;
    for(k=low;k<=hight;k++){							// 将A中所有元素复制到辅助数组B中
        B[k]=A[k];
    }
    for(i=low,j=mid+1,k=i;i<=mid&&j<=hight;k++){
        if (B[i]<=B[j]) 								/*** 将较小的值复制到数组A中
        {												这里是等于的原因，是保证算法稳定性
            A[k]=B[j++];								***/
        }
        else
        {
            A[k]=B[i++];
        }
    }
    while (i<=mid)										// 这里将剩余的有序序列复制到数组A
    {
        A[k++]=B[i++];
    }
    while (j<=hight)
    {
        A[k++]=B[j++];
    }
    
}

void MergeSort(int A[],int low,int hight){
	/************************************************* 
	Function:       // MergeSort
	Description:    // 归并排序
	Calls:          // MergeSort; Merge;
	Input:          // A[]-被排序数组 low-表头index,hight-表尾index，mid-切分成2个表
	Output:         // None
	Return:         // None 
	*************************************************/  
    if (low<hight){
        int mid = (low+hight)/2;						// 将表从中间划分
        MergeSort(A,low,mid);							// 对左表排序
        MergeSort(A,mid+1,hight);						// 对右表排序
        Merge(A,low,mid,hight);							// 归并
    }
}

4.2.Python代码示例

与C++一致，不再赘述。

五、性能分析

5.1 空间复杂度

空间复杂度=$O(n)$,来自于辅助函数.

5.2 时间复杂度

5.2.1 最坏时间复杂度

建堆时间复杂度=$O(n)$
排序的时间复杂度=$nlo{g}_{2}n$,每趟归并时间复杂度为$O(n)$，n个元素进行2路归并排序,归并趟数=$lo{g}_{2}n$

5.3 稳定性

归并排序是一个稳定的排序算法