01_05_归并排序（Merge Sort）

归并排序（Merge Sort）

归并排序（Merge Sort）介绍：

是一种常用的排序算法，它采用分治的策略将待排序的序列分成若干个子序列，分别进行排序，然后将排好序的子序列合并成最终的有序序列。

归并排序（Merge Sort）原理：

1. 将待排序序列分成两个子序列，直到每个子序列的长度为1或0，即认为子序列已经有序。
2. 将相邻的子序列进行合并，得到新的有序序列。
3. 重复上述步骤，直到所有子序列合并为最终的有序序列。

Java 代码实现：

package com.algorithm.sort;

/**
 * 归并排序的原理可以描述如下：
 * 

 * 1.将待排序序列分成两个子序列，直到每个子序列的长度为1或0，即认为子序列已经有序。
 * 2.将相邻的子序列进行合并，得到新的有序序列。
 * 3.重复上述步骤，直到所有子序列合并为最终的有序序列。
 */

public class MergeSort {

    /**
     * 归并排序算法实现
     *
     * @param arr 待排序数组
     */
    public static void mergeSort(int[] arr) {
        int n = arr.length;
        if (n <= 1) {
            return; // 当序列长度为1或0时，已经有序，无需排序
        }
        int[] temp = new int[n]; // 创建一个临时数组存储归并结果
        mergeSortRecursive(arr, temp, 0, n - 1); // 递归调用归并排序
    }

    /**
     * 使用递归实现归并排序的分治过程
     *
     * @param arr   待排数组
     * @param temp  临时数组
     * @param left  左数组下标
     * @param right 右数组下标
     */
    public static void mergeSortRecursive(int[] arr, int[] temp, int left, int right) {
        if (left >= right) {
            return; // 当子序列长度为1或0时，已经有序，无需排序
        }
        int mid = (left + right) / 2; // 计算中间位置
        mergeSortRecursive(arr, temp, left, mid); // 对左子序列进行递归排序
        mergeSortRecursive(arr, temp, mid + 1, right); // 对右子序列进行递归排序
        merge(arr, temp, left, mid, right); // 合并左右子序列
    }

    /**
     * 合并左右子序列
     *
     * @param arr   待排序数组
     * @param temp  临时数组
     * @param left  左数组下标
     * @param mid   中间位置数组下标
     * @param right 右数组下标
     */
    public static void merge(int[] arr, int[] temp, int left, int mid, int right) {
        int i = left; // 左子序列的起始索引
        int j = mid + 1; // 右子序列的起始索引
        int k = 0; // 临时数组的索引

        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++]; // 将较小的元素放入临时数组
            } else {
                temp[k++] = arr[j++];
            }
        }

        // 处理剩余的元素
        while (i <= mid) {
            temp[k++] = arr[i++];
        }
        while (j <= right) {
            temp[k++] = arr[j++];
        }

        // 将临时数组中的元素复制回原数组
        for (int m = 0; m < k; m++) {
            arr[left + m] = temp[m];
        }
    }

    /**
     * 测试方法
     *
     * @param args todo
     */
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        mergeSort(arr);
        System.out.println("排序后的数组：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

代码简单解释：

在上述代码中，mergeSort 方法接受一个整数数组 arr 作为输入，并调用 mergeSortRecursive 方法进行归并排序。mergeSortRecursive 方法使用递归实现归并排序的分治过程，将待排序序列分成两个子序列，并递归调用 mergeSortRecursive 方法对子序列进行排序。最后，调用 merge 方法将排好序的子序列合并成最终的有序序列。

程序执行结果：

排序后的数组：
11 12 22 25 34 64 90 
Process finished with exit code 0

备注：

• 归并排序的时间复杂度是 O(nlogn)，它是一种稳定的排序算法，在处理大规模数据时具有较好的性能。
• 虽然归并排序的空间复杂度较高（需要额外的临时数组），但其稳定性和可预测性使其成为一种常用的排序算法。