排序算法 - 归并排序详解

基本介绍

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

基本思想

1. 将序列中待排序数字分为若干组，最终每个数字分为一组。（默认长度为1的序列是有序的）
2. 将若干个组两两合并，保证合并后的组是有序的。（俩个子序列头部进行比较大小）
3. 重复第二步操作直到只剩下一组，排序完成。

归并排序思想示意图

分阶段可以理解为就是递归拆分子序列的过程。

合并相邻有序子序列

再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将 [4,5,7,8] 和 [1,2,3,6] 两个已经有序的子序列，合并为最终序列 [1,2,3,4,5,6,7,8] ，来看下实现步骤：

代码实现

归并排序的思想主要是利用栈的特性，递归进行分解操作，肯定是从大数组向小数组进行分解。递归进行合并操作，肯定是从小数组向大数组进行合并。

递归详解：https://blog.csdn.net/ZSA222/article/details/124541940?spm=1001.2014.3001.5502

/**
 * @ClassName MergeSortDemo
 * @author: shouanzh
 * @Description  归并排序
 * @date 2022/5/9 18:27
 */
public class MergeSortDemo {

    public static void main(String[] args) {

        int[] array = new int[]{8, 4, 5, 7, 1, 3, 6, 2};

        // 归并排序 需要额外的空间
        int[] temp = new int[array.length];

        mergeSort(array,0,array.length - 1,temp);

        System.out.println(Arrays.toString(array)); // [1, 2, 3, 4, 5, 6, 7, 8]

    }


    /**
     * 分加合的方法
     * @param array 排序的原始数组
     * @param left 左边有序序列的初始索引
     * @param right 最右边索引
     * @param temp 中转的临时数组
     */
    public static void mergeSort(int[] array, int left, int right, int[] temp) {

        if (left < right) {
            int mid = (left + right) / 2; // 中间索引
            System.out.println("分：left=" + left + " right=" + right + " mid=" + mid);
            // 左边归并排序，使得左子序列有序
            mergeSort(array,left,mid,temp);
            // 右边归并排序，使得右子序列有序
            mergeSort(array,mid + 1,right,temp);
            // 将两个有序子数组合并操作
            merge(array,left,mid,right,temp);
        }

    }


    /**
     * 合并的方法
     * @param array 排序的原始数组
     * @param left 左边有序序列的初始索引
     * @param mid 中间索引（左边有序序列最后的值的索引）
     * @param right 最右边索引
     * @param temp 中转数组
     */
    public static void merge(int[] array, int left, int mid, int right, int[] temp) {

        // 初始化i, 左边有序序列的头部初始索引
        int i = left;
        // 初始化j, 右边有序序列的头部初始索引, mid + 1
        int j = mid + 1;
        // 指向中转数组 temp 的当前索引
        int t = 0;

        // 1. 先把左右（有序）序列的数据按照规则填充到中转数组 temp
        //    直到左右俩边的有序序列有一边处理完毕为止
        while (i <= mid && j <= right) {
            // 左边有序序列头部元素 <= 右边有序序列头部元素
            if (array[i] <= array[j]) {
                // 将 array[i] 即小的数据 填充到 中转数组 temp, 并将 i 和 t 后移
                temp[t] = array[i];
                t += 1;
                i += 1;
            } else {
                // 反之 将 右边有序序列头部元素 拷贝到 中转数组 temp, 并将 j 和 t 后移
                temp[t] = array[j];
                t += 1;
                j += 1;
            }
        }

        // 2. 把有剩余数据的一边的剩余数据依次全部填充到 temp
        // 2.1 说明左边有序序列还有剩余元素， 将剩余元素全部填充到 temp
        while (i <= mid) {
            temp[t] = array[i];
            t += 1;
            i += 1;
        }
        // 2.2 说明右边有序序列还有剩余元素， 将剩余元素全部填充到 temp
        while (j <= right) {
            temp[t] = array[j];
            t += 1;
            j += 1;
        }

        // 3. 把中转数组 temp 元素 拷贝到 原始数组 array
        t = 0;
        int tempLeft = left;
        System.out.println("合并：tempLeft=" + tempLeft + "  right=" + right);
        while (tempLeft <= right) {
            array[tempLeft] = temp[t];
            t += 1;
            tempLeft += 1;
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

运行结果

分：left=0 right=7 mid=3
分：left=0 right=3 mid=1
分：left=0 right=1 mid=0
合并：tempLeft=0  right=1
分：left=2 right=3 mid=2
合并：tempLeft=2  right=3
合并：tempLeft=0  right=3
分：left=4 right=7 mid=5
分：left=4 right=5 mid=4
合并：tempLeft=4  right=5
分：left=6 right=7 mid=6
合并：tempLeft=6  right=7
合并：tempLeft=4  right=7
合并：tempLeft=0  right=7
[1, 2, 3, 4, 5, 6, 7, 8]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15