算法与数据结构（归并排序）

Fu Junzhe

已于 2022-03-27 18:08:27 修改

阅读量332

点赞数

分类专栏：算法与数据结构文章标签：算法

于 2020-04-29 21:16:48 首次发布

本文链接：https://blog.csdn.net/fujz123/article/details/105848915

版权

算法与数据结构专栏收录该内容

25 篇文章 1 订阅

订阅专栏

归并排序 Merge Sort

利用分治策略来解决排序问题

分治法 Divide and Conquer：

分治法的基本思想如下：

分解：将原问题分解为若干子问题，这些子问题是原问题的规模较小的实例。
解决：递归地求解这些子问题。当子问题规模足够小时，可直接求解。
合并：合并子问题的解成原问题的解。

归并排序算法完全遵循分治模式。其操作步骤如下：

分解：将原序列分解为两个各占 $n / 2$ 个元素的子序列。
解决：使用归并排序递归地排序两个子序列。这里的策略是不断分解直到子序列只包含一个元素，此时子序列必然有序。
合并：合并两个已排序的子序列以产生有序序列。

归并排序的思路：

如上所述，归并排序的基本思路是先将序列分为两部分，让左右两部分分别有序，然后合并。但是左右两部分的排序又重复上述过程，不断地分裂成两部分，直到最终都只有一个元素，此时所有的数组都是有序的。然后不断合并两个有序数组，直到最终成为一个整体。

其中的重点是合并步骤。假设数组为 $A$ ， $p$ 、 $q$ 和 $r$ 是数组下标。现在子数组 $A [p . . q]$ 和
$A [q + 1 . . r]$ 都已排好序，我们要合并这两个有序子数组以形成单一的有序数组并替代当前的 $A [p . . r]$ 。

还是以扑克牌为例，假设现在有两堆牌面朝上的牌，每堆都已从小到大排好序，最小的牌位于顶端。我们每一次都从两堆牌的顶上选择更小的那一张放入输出堆中，这样不断循环直到一个牌堆为空，然后将剩余的牌堆全部放入输出堆即可。合并过程用伪代码表示如下：

MERGE(A, p, q, r)
n1 = q-p+1
n2 = r-q
let L[1..n1=1] and R[1..n2+1] be new arrays
for i = 1 to n1
    L[i] = A[p+i-1]
for j = 1 to n2
    R[j] = A[q+j]
L[n1+1] = inf
R[n2+1] = inf
i = 1
j = 1
for k = p to r
    if L[i] <= R[i]
        A[k] = L[i]
        i = i+1
    else A[k] = R[j]
        j = j+1

值得注意的是可以使用哨兵来避免判断数组溢出。在第 9-10 行，我们将两个临时列表的最后一位元素设置为无穷大，当一个牌堆已经到底的时候，其哨兵牌将大于另一牌堆的所有牌（哨兵牌除外）。

之后我们就可以把上述的合并过程当作归并排序的一个子程序来使用。我们使用 $\mathrm{MERGE-SORT}(A, p, r)$ 来对子数组 $A [p . . r]$ 排序：

MERGE_SORT(A, p, r)
if p < r
    q = floor((p+r)/2) // 向下取整
    MERGE_SORT(A, p, q)
    MERGE_SORT(A, q+1, r)
    MERGE(A, p, q, r)

第 4-5 行对原序列不断分解，当全部子序列都只包含一个元素时，就已经完成了对最小子序列的排序工作，然后就开始合并。

图示如下：
分解：
在这里插入图片描述
合并：

实现：

以 Java 为例，C++代码见文末。

首先实现并的部分，当我们有两个有序数组需要合并时（这里采取的策略是用一个额外的数组 $t e m p$ 来保存排好序的数组，然后将这个 $t e m p$ 内的值返回到原数组），我们需要三个指针 $l e f t, m i d$ 和 $r i g h t$ ，分别比较两个数组中较小的那个，保存到 $t e m p$ 中。排序完毕后，将 $t e m p$ 中的数据返回到原数组中。

这里用最后一次的排序举例：
在这里插入图片描述

// java
	/**
	 * 合并数组
	 * 
	 * @param arr   排序的原始数组
	 * @param left  左边有序序列的初始索引
	 * @param mid   中间索引
	 * @param right 右边索引
	 * @param temp  临时数组
	 */
	public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
		int i = left; // 初始化 i ，左边有序序列的初始索引
		int j = mid + 1; // 初始化 j ，右边有序序列的初始索引
		int t = 0; // 指向temp数组的第一位

		// 将左右两边的数据填充到temp数组
		while (i <= mid && j <= right) {
			if (arr[i] <=  arr[j]) {
				temp[t] = arr[i];
				i++;
			}else {
				temp[t] = arr[j];
				j++;
			}
			t++;
		}
		
		// 当一边填充完毕时，另一边数组一般还有剩余
		// 将剩余元素全部填充到temp数组
		// 如果左边还有剩余
		while (i<=mid) {
			temp[t] = arr[i];
			i++;
			t++;
		}
		// 如果右边还有剩余
		while (j <= right) {
			temp[t] = arr[j];
			j++;
			t++;
		}
		
		//将temp数组元素拷贝到arr数组，并不是将temp全部拷贝到arr，而是截取部分
		t = 0;
		int tl = left;
		while (tl <= right) {
			arr[tl] = temp[t];
			tl++;
			t++;
		}
	}

然后是拆分部分，主要是递归

代码如下：

// java
    public static void mergeSort(int[] arr, int left, int right, int[] temp) {
      if (left < right) {
        int mid = (left + right)/2;
        // 向左分解
        mergeSort(arr, left, mid, temp);
        // 向右分解
        mergeSort(arr, mid+1, right, temp);
        // 合并
        merge(arr, left, mid, right, temp);
      }
    }

下图是逻辑顺序：
在这里插入图片描述

时间复杂度：

归并排序的时间复杂度主要考虑两个函数需要的时间，即 mergeSort 和 merge

merge 合并的时间复杂度为 $O (n)$ ，因为全部都是长度为 $n$ 的一次循环

利用之前说过的递归的时间复杂度公式，归并排序的时间复杂度为 $T (n) = 2 (T (n / 2)) + O (n)$

这个递归式可以用递归树来解（假设解决最后一步子问题的时间是常数 $c$ ，则 $n$ 个子问题花费的时间为 $c n$ ）：
在这里插入图片描述
我们可以看到递归的每一层需要的时间都是 $c n$ ，总共有 $l o g n + 1$ 层，总的时间为 $c n (l o g n + 1)$ ，时间复杂度是 $O (n l o g n)$ 。

空间复杂度：

归并排序在每一次合并时需要临时数组来储存排好序的序列，最后一次排序，要储存的数字最多，为 $n$ ，所以空间复杂度为 $O (n)$ 。

稳定性：

归并排序可以保证等值元素之间的顺序，因此是稳定的

C++ 实现：

#include <iostream>
#include <vector>
using namespace std;

/**
 * @brief Merge two ordered lists(nums[low..mid], nums[mid+1..high]).
 * 
 * @param nums 
 * @param low 
 * @param mid 
 * @param high 
 */
void merge(vector<int>& nums, int low, int mid, int high) {
    int len1 = mid-low+1;
    int len2 = high-mid;
    vector<int> left(len1+1);
    vector<int> right(len2+1);
    for (int i=0;i<len1;i++) {
        left[i] = nums[i+low];
    }
    for (int j=0;j<len2;j++) {
        right[j] = nums[j+mid+1];
    }
    // 设置哨兵
    left[len1] = INT_MAX;
    right[len2] = INT_MAX;

    // 合并 
    int i = 0;
    int j = 0;
    for (int k=low;k<=high;k++) {
        if (left[i] <= right[j]) {
            nums[k] = left[i++];
        } else {
            nums[k] = right[j++];
        }
    }

}


void mergeSort(vector<int>& nums, int low, int high) {
    if (low < high) {
        int mid = (high-low)/2+low;
        mergeSort(nums, low, mid);
        mergeSort(nums, mid+1, high);
        merge(nums, low, mid, high);
    }
}

// test
int main(int argc, char const *argv[])
{
    vector<int> nums = {4,7,2,9};
    mergeSort(nums, 0, nums.size()-1);
    for (auto num : nums) {
        cout << num << endl;
    }
    return 0;
}

Fu Junzhe

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
算法与数据结构（归并排序）

归并排序 Merge Sort利用分治策略来解决排序问题分治法 Divide and Conquer：分：将大问题分成一些小的问题然后分别求解；治：将求出来的答案组合到一起，形成最初问题的答案归并排序的思路：归并排序的基本思路是先将序列分为两部分，让左右两部分分别有序，然后合并。但是左右两部分的排序又重复上述过程，不断地分裂成两部分，直到最终都只有一个元素，此时所有的数组都是有序...
复制链接

扫一扫