时间复杂度为O(nlogn)的排序（JAVA）

时间复杂度为O(nlogn)的排序

归并排序

思路

一个数组，前后一分为二，只要把两个数组都排好序，最后将两个数组合并到一起，就完成了整个数组的排序。
这种解决问题的思想叫“分治”，解决一个大问题的途径是通过解决若干个小问题来完成的。
举个例子，有数组[4,6,2,8,1]
前后一分为二：[4,6,2]，[8,1]
需要分别完成上述两个数组的排序后，最终合并两数组
完成[4,6,2]的排序是接着一分为二：[4,6]，[2]，…
完成[4,6]的排序是接着一分为二：[4]，[6]，到此处无法再分了，就进行合并操作
于是[4]和[6]合并为了[4,6]，再和[2]合并为[2,4,6]
而[8,1]那边通过一系列操作得到的是[1,8]
最终[2,4,6]和[1,8]合并得到[1,2,4,6,8]，完成排序

这里用到了递归调用

写递归代码的过程

递归方法中要完成下边几件事
第一，判断要排序的数组长度是否大于1，如果为1或为空，直接返回
第二，解决数组左半部分的排序（调用本递归方法）
第三，解决数组右半部分的排序（调用本递归方法）
第四，合并两部分有序数组为一个数组，完成排序
先放一下最早写的代码

import java.util.Arrays;

import org.junit.Test;

public class MergeSort {
   

    public int[] mergeSort(int[] array, int length) {
   
        if (length <= 1) {
   
            return array;
        }
        int mid = (length - 1) / 2;
        // copyOfRange方法的from to是左闭右开的，所以left获取的是index从0到mid的，right获取到的是index从mid+1到length-1的
        int[] left = Arrays.copyOfRange(array, 0, mid + 1);
        int[] right = Arrays.copyOfRange(array, mid + 1, length);
        return merge(mergeSort(left, left.length), mergeSort(right, right.length));
    }

    private int[] merge(int[] left, int[] right) {
   
        if (left == null || left.length == 0) {
   
            return right;
        }
        if (right == null || right.length == 0) {
   
            return left;
        }
        int[] temp = new int[left.length + right.length];
        int leftPos = 0;
        int rightPos = 0;
        int tempPos = 0;
        while (leftPos < left.length && rightPos < right.length) {
   
            if (left[leftPos] < right[rightPos]) {
   
                temp[tempPos++] = left[leftPos++];
            } else {
   
                temp[tempPos++] = right[rightPos++];
            }
        }
        if (leftPos == left.length) {
   
            while (rightPos < right.length) {
   
                temp[tempPos++] = right[rightPos++];
            }
        } else {
   
            while (leftPos < left.length) {
   
                temp[tempPos++] = left[leftPos++];
            }
        }
        return temp;
    }

    @Test
    public void test() {
   
        int[] array1 = {
   6, 9, 1, 5, 9, 4, 2};
        System.out.println(Arrays.toString(mergeSort(array1, array1.length)));
        int[] array2 = {
   6, 9, 1, 5, 9, 4, 2, 7};
        System.out.println(Arrays.toString(mergeSort(array2, array2.length)));
    }

}

在递归方法mergeSort中完成了上述四件事。但每次调用两次Arrays.copyOfRange生成新数组，有些浪费空间，可以使用传递索引范围来确定要处理的数组（类似从index=0到index=length-1），写一个重载的方法mergeSort，下边是伪代码

// 原mergeSort入参中有数组长度，这里left和right相应的就是left=0,right=length-1
public void mergeSort(int[] array, int left, int right) {
   
	// 对应于length<=1时return，相当于length-1<=0,也就是right<=left时return
	if(left >= right) {
   
		return;
	}
	// 确定一个中间索引mid
	int mid = (left + right) / 2;
	// 这里有种更装逼的写法，当left和right都足够大的时候，相加可能超出int最大范围，这里最好改写为
	mid = left + (right - left) / 2;
	// 如新的重载方法中描述，right指定的索引是有效的，那左半部分的数组索引就确定了,从left到mid；右半部分的数组索引就是，从mid+1到right
	mergeSort(array, left, mid);
	mergeS