【算法】归并排序详解

最新推荐文章于 2024-09-10 15:28:21 发布

Gmerrysong

最新推荐文章于 2024-09-10 15:28:21 发布

阅读量376

点赞数 1

分类专栏：算法文章标签：算法排序算法 java

本文链接：https://blog.csdn.net/m0_61832361/article/details/132650959

版权

算法专栏收录该内容

7 篇文章 1 订阅

订阅专栏

在这里插入图片描述

归并排序详解

归并排序
代码实现
- 1. 递归版本
- 2. 非递归版本

排序：排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中， r[i] = r[j]，且 r[i] 在 r[j] 之前，而在排序后的序列中， r[i] 仍在 r[j] 之前，则称这种排序算法是稳定的；否则称为不稳定的。
（注意稳定排序可以实现为不稳定的形式，而不稳定的排序实现不了稳定的形式）

在这里插入图片描述

内部排序：数据元素全部放在内存中的排序。

外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序核心步骤：

分解（Divide）：将n个元素分成两个个含n/2个元素的子序列。
解决（Conquer）：用合并排序法对两个子序列递归的排序。
合并（Combine）：合并两个已排序的子序列已得到排序结果。

在这里插入图片描述

代码实现

1. 递归版本

	public static void mergeSort(int[] arr) {
        int len = arr.length;
        partition(arr, 0, len-1);
    }


    public static void partition(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        // 将区间分成左右两个部分, 并将两个部分分别排序
        int mid = ((right-left) >> 1) + left;
        partition(arr, left, mid);
        partition(arr, mid+1, right);
        // 将两部分合并
        int[] temp = new int[right-left+1];
        int index = 0;
        int index1 = left;
        int index2 = mid+1;
        while (index1 <= mid && index2 <= right) {
            if (arr[index1] < arr[index2]) {
                temp[index++] = arr[index1++];
            } else {
                temp[index++] = arr[index2++];
            }
        }
        while (index1 <= mid) {
            temp[index++] = arr[index1++];
        }
        while (index2 <= right) {
            temp[index++] = arr[index2++];
        }
        // 重新拷贝回去
        for (int i = 0; i < index; i++) {
            arr[left+i] = temp[i];
        }
    }

2. 非递归版本

    public static void mergeSortNonR(int[] arr) {
        int len = arr.length;
        // i 表示的是, 左右区间中每个区间的元素个数
        for (int i = 1; i < len; i*=2) {
            // j 每次要跳过两个区间
            for (int j = 0; j < len; j += 2*i) {
                int left1 = j;
                int right1 = j + i - 1;
                int left2 = right1 + 1;
                int right2 = left2 + i - 1;
                // 修正一下 right1, right2, 因为可能 right1 和 right2 越界了
                if (right1 >= len) {
                    right1 = len-1;
                }
                if (right2 >= len) {
                    right2 = len - 1;
                }
                // 开始合并
                int[] temp = new int[2*i];
                int index = 0;
                while (left1 <= right1 && left2 <= right2) {
                    if (arr[left1] <= arr[left2]) {
                        temp[index++] = arr[left1++];
                    } else {
                        temp[index++] = arr[left2++];
                    }
                }
                while (left1 <= right1) {
                    temp[index++] = arr[left1++];
                }
                while (left2 <= right2) {
                    temp[index++] = arr[left2++];
                }
                // 拷贝回去
                for (int k = 0; k < index; k++) {
                    arr[j+k] = temp[k];
                }
            }
        }
    }