算法重温：排序 —— 合并排序

Itempor

已于 2022-12-25 17:15:34 修改

阅读量6.7k

点赞数 6

文章标签：算法数据结构排序算法 1024程序员节

于 2022-10-20 14:03:35 首次发布

本文链接：https://blog.csdn.net/weixin_50553521/article/details/127425458

版权

1. 基本思想

通过一趟排序将待排序列分割成两部分，其中一部分记录的关键字均比另一部分记录的关键字小。之后分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

2. 排序原理

将整个数组不断采用二分法拆分至不能继续拆分，即每组只有一个数据，再把它们两组两组合并到一起，并在合并过程中进行排序，直至把整个数据合到一组为止。

3. 排序过程

以从小到大排列为例，设原数组 [8, 4, 5, 7, 1, 3, 6, 2]
拆分
第一次：[8, 4, 5, 7] [1, 3, 6, 2]
第二次：[8, 4] [5, 7] [1, 3] [6, 2]
第三次：[8] [4] [5] [7] [1] [3] [6] [2]
合并并排序
第一次：[4, 8] [5, 7] [1, 3] [6, 2]
第二次：[4, 5, 7, 8] [1, 2, 3, 6]
第三次：[1, 2, 3, 4, 5, 6, 7, 8]

4.复杂度分析

平均时间复杂度	O(nlogn)
最好情况	O(nlogn)
最坏情况	O(nlogn)
空间复杂度	O(n)
稳定性	稳定

5.代码实现 (C++、java)

方法解析以C++为例，完整代码含C++，Java

mergeSort

传入参数为要排序的数组、数组长度

对要排序的数组使用二分法进行划分处理，再分别递归处理划分后的数组，具体代码如下：

void mergeSort(int* A, int lenA) {
	if (lenA > 1) {	// 数组A还能被分配
		// 分治
		int n1 = lenA / 2;
		int n2 = lenA - n1;
		// 将A拆成B与C两个数组
		int* B = (int*)malloc(sizeof(int) * n1);	// 动态分配
		int* C = (int*)malloc(sizeof(int) * n2);
		for (int i = 0; i < n1; i++) {
			B[i] = A[i];
		}
		for (int i = 0; i < n2; i++) {
			C[i] = A[n1 + i];
		}
		// 递归
		mergeSort(B, n1);
		mergeSort(C, n2);
		// 合并
		merge(B, n1, C, n2, A, lenA);
		// 释放内存
		free(B);
		free(C);
	}
}

merge

传入参数为二分后的两个数组和原数组及它们的数组长度

将两个数组按顺序插入，替换掉原数组的值，使原数组有序，具体代码如下：

void merge(int* B, int lenB, int* C, int lenC, int* A, int lenA) {	// 合并
	int i = 0, j = 0, k = 0;		// i对应数组B, j对应数组C, k对应数组A
	while (i < lenB && j < lenC) {	// 数组B和数组C的数都没被分配完的情况
		if (B[i] <= C[j]) A[k++] = B[i++];	// 升序，从小到大	 将较小的先合并进新数组
		else A[k++] = C[j++];
	}
	if (i == lenB) {	// 数组B被分配完，数组C剩余的依次分配进新数组
		while (j < lenC) A[k++] = C[j++];
	}
	else {				// j == lenC	数组C被分配完，数组B剩余的依次分配进新数组
		while (i < lenB) A[k++] = B[i++];
	}
}

完整代码

C++

// c++

#include<iostream>
#include<cstdlib>
using namespace std;
void mergeSort(int* A, int lenA);
void merge(int* B, int lenB, int* C, int lenC, int* A, int lenA);
int main() {
	int n;
	cout << "请输入数组长度：";
	cin >> n;
	cout << "\n输入整数数组：";
	int* a = (int*)malloc(sizeof(int) * n);		// 动态分配
	for (int i = 0; i < n; i++) {
		cin >> a[i];
	}
	mergeSort(a, n);
	cout << "\n排序后数组为：";
	for (int i = 0; i < n; i++) {
		cout << a[i] << " ";
	}
}
void mergeSort(int* A, int lenA) {
	if (lenA > 1) {	// 数组A还能被分配
		// 分治
		int n1 = lenA / 2;
		int n2 = lenA - n1;
		// 将A拆成B与C两个数组
		int* B = (int*)malloc(sizeof(int) * n1);	// 动态分配
		int* C = (int*)malloc(sizeof(int) * n2);
		for (int i = 0; i < n1; i++) {
			B[i] = A[i];
		}
		for (int i = 0; i < n2; i++) {
			C[i] = A[n1 + i];
		}
		// 递归
		mergeSort(B, n1);
		mergeSort(C, n2);
		// 合并
		merge(B, n1, C, n2, A, lenA);
		// 释放内存
		free(B);
		free(C);
	}
}
void merge(int* B, int lenB, int* C, int lenC, int* A, int lenA) {	// 合并
	int i = 0, j = 0, k = 0;		// i对应数组B, j对应数组C, k对应数组A
	while (i < lenB && j < lenC) {	// 数组B和数组C的数都没被分配完的情况
		if (B[i] <= C[j]) A[k++] = B[i++];	// 升序，从小到大	 将较小的先合并进新数组
		else A[k++] = C[j++];
	}
	if (i == lenB) {	// 数组B被分配完，数组C剩余的依次分配进新数组
		while (j < lenC) A[k++] = C[j++];
	}
	else {				// j == lenC	数组C被分配完，数组B剩余的依次分配进新数组
		while (i < lenB) A[k++] = B[i++];
	}
}

Java

// java

import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        System.out.print("请输入数组的长度：");
        int size = in.nextInt();
        int[] a = new int[size];
        System.out.println("请输入数组：");
        for(int i = 0; i < size; i++){
            a[i] = in.nextInt();
        }
        System.out.println("排序后数组：");
        mergeSort(a,a.length);
        for(int k = 0; k < a.length; k++){
            System.out.print(a[k]+" ");
        }
    }
    public static void mergeSort(int[] A,int lenA){
        if(lenA > 1){   // 数组A还能被分配
            // 分治
            int n1 = lenA/2;
            int n2 = lenA - n1;
            // 将A拆成B与C两个数组
            int[] B = new int[n1];
            int[] C = new int[n2];
            for(int i = 0; i < n1; i++){
                B[i] = A[i];
            }
            for(int i = 0; i < n2; i++){
                C[i] = A[n1 + i];
            }
            // 递归
            mergeSort(B,n1);
            mergeSort(C,n2);
            // 合并
            merge(B,n1,C,n2,A,lenA);
        }
    }
    public static void merge(int[] B,int lenB,int[] C,int lenC,int[] A,int lenA){   // 合并
        int i = 0,j = 0,k = 0;          // i对应数组B, j对应数组C, k对应数组A
        while (i < lenB && j < lenC){   // 数组B和数组C的数都没被分配完的情况
            if(B[i] <= C[j]) { A[k++] = B[i++]; }   // 升序，从小到大	 将较小的先合并进新数组
            else { A[k++] = C[j++]; }
        }
        if(i == lenB){      // 数组B被分配完，数组C剩余的依次分配进新数组
            while(j < lenC) { A[k++] = C[j++]; }
        }else {             // j == lenC	数组C被分配完，数组B剩余的依次分配进新数组
            while(i < lenB) { A[k++] = B[i++]; }
        }
    }
}