JAVA归并排序代码

直接插入算法学习使用代码如下

package mergeSort;

import java.util.Arrays;

/**
 * 归并 - 递归
 *                     {5, 3, 6, 2, 1, 9, 4, 8}
 *
 *             {5, 3, 6, 2}                {1, 9, 4, 8}
 *
 *         {5,3}         {6,2}          {1,9}         {4,8}
 *
 *      {5}   {3}       {6}   {2}     {1}  {9}          {4}   {8}
 *
 *
 *           说明：  public static void sort(int[] arr, int left, int right)方法：
 *
 *             此处每次都传入的是 原数组 arr
 *
 *             首次：sort(arr, left = 0, center = (0 +  length -1) / 2 );
 *             即 前半个数组
 *
 *             sort(arr, center + 1 = (0 +  length -1) / 2 +1 , arr.length - 1);
 *
 *             依此类推。。。
 *
 *             倒数第二次  左半边数组
 *             sort(arr, left = 0, center = 2);
 *             即传入的数组只处理 下表从0到2的元素
 *
 *
 */
public class Merge {
    // 记录第几趟排序，可删除
    static int count = 1;

    public static void main(String[] args) {
		int[] arr = new int[] {55, 3, 55, 2, 5, 9, 4, 7};
        System.out.println("原数组长度： " + arr.length);
        System.out.println("原数组： " + Arrays.toString(arr));
        mergeSort(arr);
        System.out.println("排序后的数组： " + Arrays.toString(arr));
    }

    public static void mergeSort(int[] arr) {
        if (null == arr) {
            return;
        }
        sort(arr, 0, arr.length - 1);
    }

    /**
     * @param arr   当前数组
     * @param left  当前数组的第一个元素
     * @param right 当前数组的最后一个元素
     */
    public static void sort(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        // 找出中间索引
        int center = (left + right) / 2;

        // 对左边数组进行递归
        sort(arr, left, center);
        // 对右边数组进行递归
        sort(arr, center + 1, right);
        // 合并
        merge(arr, left, center, right);
    }


    /**
     * @param arr    当前数组
     * @param left   当前数组的第一个元素
     * @param center 当前数组中的中间元素
     * @param right  当前数组中的最后一个元素
     */
    public static void merge(int[] arr, int left, int center, int right) {
        int length = arr.length;

        // 准备一个新的数组用于存储比对后的数据
        int[] tmpArr = new int[length];
        // tmpArrIndex 新的数组的索引
        int tmpArrIndex = left;

        // 右数组第一个元素索引
        int mid = center + 1;
        // 缓存左数组第一个元素的索引,用于将临时数组中的内容拷贝回原数组使用
        int index = left;

        while (left <= center && mid <= right) {
            // 从两个数组中取出最小的放入临时数组
            if (arr[left] <= arr[mid]) {
                tmpArr[tmpArrIndex++] = arr[left++];
            } else {
                tmpArr[tmpArrIndex++] = arr[mid++];
            }
        }
        // 处理剩余部分数组数据
        while (mid <= right) {
            tmpArr[tmpArrIndex++] = arr[mid++];
        }
        while (left <= center) {
            tmpArr[tmpArrIndex++] = arr[left++];
        }
         //以上代码只是将arr数组中的数据进行了排序，排序的结果在tmpArrIndex数组中

        //所以每次排序之后都需要将有序的数组写入原数组中
        while (index <= right) {
            arr[index] = tmpArr[index++];
        }

        System.out.println("第 " + count + "趟排序比较之后的内容" + Arrays.toString(tmpArr));
        count++; //可删除，无作用
    }

}