Java - 归并排序算法介绍、应用场景和示例代码

概述

归并排序（Merge Sort）是一种基于分治策略的排序算法。其核心思想是将原始数组分成更小的子数组，分别对每个子数组进行排序，然后合并已排序的子数组以得到最终的排序结果。

算法步骤

1. 分割：将数组递归地分成两半，直到每个子数组只有一个元素（自然是有序的）。
2. 合并：将两个有序的子数组合并成一个有序数组。合并时通过比较两个子数组的元素，按顺序将元素放入结果数组中。

应用场景

归并排序特别适合处理大规模数据和需要稳定排序的场景（即相等元素的顺序不改变）。由于归并排序始终分割数组并合并结果，它在最坏情况下也能保持较优的性能表现。

算法特点

• 稳定排序：相同元素的相对顺序在排序过程中保持不变。
• 时间复杂度：在所有情况下（最好、最坏、平均），时间复杂度均为 O(nlog⁡n)O(n \log n)O(nlogn)。
• 空间复杂度：需要额外的 O(n)O(n)O(n) 空间来保存临时数组。

示例代码

下面是一个用 Java 实现的归并排序示例代码：

public class MergeSort {

    public static void mergeSort(int[] arr) {
        if (arr.length < 2) {
            return; // 数组已经是有序的
        }
        int mid = arr.length / 2;
        int[] left = new int[mid];
        int[] right = new int[arr.length - mid];

        // 分割数组
        System.arraycopy(arr, 0, left, 0, mid);
        System.arraycopy(arr, mid, right, 0, arr.length - mid);

        // 递归排序左半部分和右半部分
        mergeSort(left);
        mergeSort(right);

        // 合并两个已排序的数组
        merge(arr, left, right);
    }

    private static void merge(int[] arr, int[] left, int[] right) {
        int i = 0, j = 0, k = 0;
        
        // 合并两个子数组
        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                arr[k++] = left[i++];
            } else {
                arr[k++] = right[j++];
            }
        }
        
        // 复制剩余的元素
        while (i < left.length) {
            arr[k++] = left[i++];
        }
        
        while (j < right.length) {
            arr[k++] = right[j++];
        }
    }

    public static void main(String[] args) {
        int[] arr = {38, 27, 43, 3, 9, 82, 10};
        System.out.println("排序前数组:");
        printArray(arr);
        
        mergeSort(arr);
        
        System.out.println("排序后数组:");
        printArray(arr);
    }

    public static void printArray(int[] arr) {
        for (int i : arr) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

代码解析

1. 分割数组：mergeSort 方法通过递归将数组分割为两个部分。
2. 递归排序：对分割后的子数组递归调用 mergeSort 进行排序。
3. 合并操作：merge 方法负责将两个有序子数组合并为一个有序数组。
   • 通过两个指针遍历两个子数组，比较当前元素，将较小的元素放入目标数组中。
   • 将剩余元素复制到目标数组中。

优缺点

• 优点：
  • 时间复杂度始终为 O(nlog⁡n)O(n \log n)O(nlogn)，即使在最坏情况下也是如此。
  • 算法是稳定的，适合用于需要稳定排序的场合。
• 缺点：
  • 需要额外的内存空间来存储临时数组。
  • 当数据量较小时，递归和数组复制开销可能会导致性能不如其他简单的排序算法。