归并排序 - Java

方法一：

/**
* 归并排序
*/
public class MergeSort {
    
    public static void main(String[] args) {
        int[] arr = {8, 1, 7, 9, 6, 0, 5, 3, 2};
        // 排序 - 分治算法
        sort(arr, 0, arr.length - 1);
        for (int num : arr) {
            System.out.println(num);
        }
    }
    
    /**
    * 分治算法
    * left 表示左侧索引，right 是右侧索引，用于要排序的arr的子数组
    */
    public static void sort(int[] arr, int left, int right) {
        if (left < right) {
            // 此处一句等价于 int middle = (left + right) / 2，但是可以避免当 left 和 right 很大时的溢出问题
            int middle = (right - left) / 2 + left;
            // 对左右两半进行排序
            sort(arr, left, middle);
            sort(arr, middle + 1, right);
            // 合并
            merge(arr, left, middle, right);
        }
    }
    
    /**
    * 合并arr []的两个子数组。
    * 第一个子数组是arr [left ... m]
    * 第二个子数组是arr [m + 1 ... right]
    */
    public static void merge(int[] arr, int left, int middle, int right) {
        int LEFT_SIZE = middle - left + 1;
        int RIGHT_SIZE = right - middle;
        
        //创建临时数组
        int[] leftArr = new int[LEFT_SIZE];
        int[] rightArr = new int[RIGHT_SIZE];
        
        //将数据复制到临时数组 leftArr[] 和 rightArr[]
        for (int i = 0; i < LEFT_SIZE; i ++) 
            leftArr[i] = arr[left + i];
        for (int j = 0; j < RIGHT_SIZE; j ++)
            rightArr[j] = arr[middle + j + 1];
        
        //将临时数组合并回 arr[left ... right]
        // 初始化 leftArr、rightArr、合并的arr 的初始值
        int m = 0, n = 0, p = left;
        while (m < LEFT_SIZE && n < RIGHT_SIZE) {
            if (leftArr[m] <= rightArr[n]) {
                arr[p] = leftArr[m];
                m ++;
            } else {
                arr[p] = rightArr[n];
                n ++;
            }
            p ++;
        }
        
        //如果有的话，复制 leftArr[] 的剩余元素
        while (m < LEFT_SIZE) {
            arr[p] = leftArr[m];
            m ++;
            p ++;
        }
        
        //如果有的话，复制 rightArr[] 的剩余元素
        while (n < RIGHT_SIZE) {
            arr[p] = rightArr[n];
            n ++;
            p ++;
        }
    }
}

---

方法二：

public class TestMergeSort {
    public static void main(String[] args) {
        int[] originalArr = {2, 7, 1 , 9, 3, 5, 0};
        int left = 0;
        int right = originalArr.length - 1;
        mergeSort(originalArr, left, right);
        
        for (int i : originalArr) {
            System.out.println(i);
        }
    }
    
    public static void mergeSort(int[] arr, int left, int right) {
        if (left < right) {
            int middle = (left + right) / 2;
            mergeSort(arr, left, middle);
            mergeSort(arr, middle + 1, right);
            merge(arr, left, middle + 1, right);
        }
    }
    
    public static void merge(int[] arr, int left, int middle, int right) {
        int LEFT_SIZE = middle - left;
        int RIGHT_SIZE = right - middle + 1;
        
        int[] leftArr = new int[LEFT_SIZE];
        int[] rightArr = new int[RIGHT_SIZE];
        
        int i = 0;
        
        for (i = left; i < middle; i ++) {
            leftArr[i - left] = arr[i];
        }
        
        for (i = middle; i <= right; i ++) {
            rightArr[i - middle] = arr[i];
        }
        
        int m = 0, n = 0, k = left;
        while (m < LEFT_SIZE && n < RIGHT_SIZE) {
            if (leftArr[m] < rightArr[n]) {
                arr[k] = leftArr[m];
                m ++;
                k ++;
            } else {
                arr[k] = rightArr[n];
                n ++;
                k ++;
            }
        }
        
        while (m < LEFT_SIZE) {
            arr[k] = leftArr[m];
            m ++;
            k ++;
        }
        
        while (n < RIGHT_SIZE) {
            arr[k] = rightArr[n];
            n ++;
            k ++;
        }
    }
}

感谢b站 正月点灯笼 的视频，我也是看了他的视频才学会归并排序的！

归并排序视频地址：归并排序视频地址

总结：

方法一和方法二都是一样的，只是数组的索引有稍微差别，大家可以都看一下，理解一下两种方法中 index 的区别。