归并排序 Java

分治法，分而治之

将一个数组不断地一分为二，直到划分后的子数组的长度小于等于2时，不用再划分，如果子数组长度等于2，那么需要比较这两个元素的大小关系，如果子数组长度等于1，那么直接返回上一层

当两个子数组都有序以后，“划分”这个阶段就结束了，需要开始“合并”，初始化一个right-left+1长度的数组，临时存放合并的结果，合并完成后，在将临时数组中的值，赋到原来的数组中

import java.util.Arrays;

public class Main {

    int[] nums = new int[]{9, 8, 4, 7, 6};


    public static void main(String[] args) {
        new Main().sort();

    }

    public void sort() {

        int left = 0;
        int right = nums.length - 1;
        mergeSort(left, right);
        print(left, right);
    }

    public void mergeSort(int left, int right) {
        if (left == right) {
            return;
        }
        if (right - left == 1) {
            int tmp = nums[left];
            nums[left] = nums[right];
            nums[right] = tmp;
            return;
        }
        int mid = (left + right) / 2;
        mergeSort(left, mid);
        
        //打印输出[left,mid]区间的值
        print(left, mid);
        
        mergeSort(mid + 1, right);
        
        //打印输出[mid+1,right]区间的值
        print(mid + 1, right);

        int i = left;
        int j = mid + 1;

		//初始化一个临时数组，暂时存放合并后的结果
		//在合并完成后，在将临时数组中的值，赋给原来的数组
        int[] tmpArr = new int[right - left + 1];
        int index = 0;
        while (i <= mid || j <= right) {
            if (i > mid) {
                tmpArr[index++] = nums[j++];
                continue;
            }
            if (j > right) {
                tmpArr[index++] = nums[i++];
                continue;
            }
            if (nums[i] > nums[j]) {
                tmpArr[index++] = nums[j++];
            } else {
                tmpArr[index++] = nums[i++];
            }
        }

        for (int k = 0; k < tmpArr.length; k++) {
            nums[left + k] = tmpArr[k];
        }

    }

    public void print(int left, int right) {
        System.out.print("left = " + left + ", right = " + right + ",[");
        for (int i = left; i <= right; i++) {
            System.out.print(nums[i] + ",");
        }
        System.out.println("]");
    }

}

输出结果是：

对于归并排序，还可以继续优化

比如，在数组长度较短时，可以直接使用插入排序
还有在合并时，先判断nums[mid]和nums[mid+1]的大小，如果nums[mid]<nums[mid+1]，则从left至right已经是有序的，不用再比较一次

可参考的其他博客：

• java实现归并排序（详解）