【基础5】归并排序

核心思路

归并排序基本思想是将一个数组分成两个子数组，分别对这两个子数组进行排序，然后将排好序的子数组合并成一个最终的有序数组，即分治法：

1. 分：将数组递归拆分成左右两半，直到每个子数组只剩1个元素（天然有序）。
2. 治：将两个有序子数组合并为一个有序数组，直到合并成完整数组。

优缺点

优点	​缺点
✅ 稳定排序（相等元素顺序不变）	❌ 额外空间（需O(n)临时数组）
✅ 时间复杂度稳定O(n logn)	❌ 递归可能栈溢出（极大数据量时）
✅ 适合大数据量、外排序	❌ 对小数据量效率不如插入排序

适用范围

1. 大数据量
2. 稳定性高要求（多次排序顺序必须相同）
3. 外排序（处理无法一次性装入内存的数据，如大文件拆散排序）
4. 链表排序（归并排序是链表排序的最佳选择之一）

复杂度

时间复杂度：O(n logn)，空间复杂度：O(n)

代码实现（Java）

public class MergeSort {
    public static void sort(int[] arr) {
        if (arr == null || arr.length <= 1) return;
        //通用临时数组
        int[] temp = new int[arr.length]; 
        mergeSort(arr, 0, arr.length - 1, temp);
    }

    private static void mergeSort(int[] arr, int left, int right, int[] temp) {
        //递归终止条件：只剩1个元素
        if (left >= right){
            return; 
        }
        //分成左右子区间递归排序（逻辑分开，没有物理分开）
        int mid = left + (right - left)/2;
        mergeSort(arr, left, mid, temp);
        mergeSort(arr, mid + 1, right, temp); 
        //合并左右两部分
        merge(arr, left, mid, right, temp);   
    }

    private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        //左半部分起始
        int i = left;    
        //右半部分起始
        int j = mid + 1; 
        //临时数组索引
        int t = 0;       

        //左右两部分按大小顺序合并到临时数组
        while (i <= mid && j <= right) {
            //强稳定性关键：相等时也取左区间元素
            if (arr[i] <= arr[j]) {
                temp[t++] = arr[i++]; 
            }else {
                temp[t++] = arr[j++];
            }
        }

        //剩余元素拷贝到临时数组
        while (i <= mid) temp[t++] = arr[i++];
        while (j <= right) temp[t++] = arr[j++];

        //将临时数组数据拷贝回原数组
        t = 0;
        while (left <= right){
            arr[left++] = temp[t++];
        }
    }
}

流程示例

1.原始数组： [8,3,5,1,7,4]

2.第一次分解 → [8,3,5] 和 [1,7,4]

3.继续分解左半部分：[8,3,5] → [8,3] 和 [5]，[8,3] → [8] 和 [3]

继续分解右半部分：[1,7,4] → [1,7] 和 [4] [1,7] → [1] 和 [7]

4.合并 [8] 和 [3] → [3,8]

5.合并 [3,8] 和 [5] → [3,5,8]（左半部分完成）

6.合并 [1] 和 [7] → [1,7]

7.合并 [1,7] 和 [4] → [1,4,7]（右半部分完成）

8.合并左右两部分 [3,5,8] 和 [1,4,7] → [1,3,4,5,7,8]