Java 实现归并排序

归并排序

主要思想

归并排序，主要是分而治之的思想，将待排序数组对半划分，递归直至分成单个元素，最后进行两路合并，并复制回原数组

复杂度：时间复杂度O(n logn)，空间复杂度O(n)，空间复杂度可以通过采取一些优化手段降至 O(1)

稳定性：稳定，合并时，可以保证相同元素的相对顺序

public class MergeSort {

    public static void main(String[] args) {
        int[] arr = new int[10];
        for (int i = 0; i < 10; i++) {
            arr[i] = new Random().nextInt(100);
        }

        System.out.println("排序前");
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();

        mergeSort(arr, new int[arr.length],0, arr.length - 1);

        System.out.println("排序后");
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }

    private static void mergeSort(int[] nums, int[] temp, int left, int right) {
        // 归并排序：分而治之，将数组对半递归直至分成单个元素，最后两路合并，并复制回原数组，稳定
        if (left < right) {
            int mid = (left + right) / 2;
            mergeSort(nums, temp, left, mid);
            mergeSort(nums, temp, mid + 1, right);
            // 两个数组的起始下标
            int l_pos = left;
            int r_pos = mid + 1;
            // 开始合并的 temp 下标
            int pos = left;
            // 两路合并
            while (l_pos <= mid && r_pos <= right) {
                // 保证相对顺序，左边的数组先合并
                if (nums[l_pos] <= nums[r_pos]) {
                    temp[pos++] = nums[l_pos++];
                } else {
                    temp[pos++] = nums[r_pos++];
                }
            }
            // 可能会剩余的元素
            while (l_pos <= mid) {
                temp[pos++] = nums[l_pos++];
            }
            while (r_pos <= right) {
                temp[pos++] = nums[r_pos++];
            }
            // 复制回 nums
            while (left <= right) {
                nums[left] = temp[left];
                left++;
            }
        }
    }

}