Java归并排序的递归与非递归实现

该命题已有无数解释，备份修改后的代码

平均时间复杂度： O(NLogN)  以2为底

最好情况时间复杂度： O(NLogN)

最差情况时间复杂度： O(NLogN)

所需要额外空间： 递归：O(N + LogN)， 非递归：O（N）

稳定性： 稳定

归并排序基于分治（快排也是），利用归并来实现排序，其基本思想是：

　　如果一个数组有n个数据，则可以把这个数组看作n个有序的子序列，每个子序列的长度为1，然后两两归并，就能得到[n/2]个长度为2（或者1，落单的)的字序列，再不断地两两归并，直到得到一个长度为n的有序数组。

 

递归：

public static void main(String[] args) {
    int[] nums = {6, 5, 3, 8, 1, 7, 2, 9, 4};
    segment(nums, 0, nums.length - 1);
    System.out.println(Arrays.toString(nums));
}

/**
 * 递归切分待排
 *
 * @param nums  待切分数组
 * @param left  待切分最后第一个元素的索引
 * @param right 待切分数组最后一个元素的索引
 */
private static void segment(int[] nums, int left, int right) {
    if (left < right) {
        // 找出中间索引
        int center = (left + right) / 2;
        // 对左边数组进行递归
        segment(nums, left, center);
        // 对右边数组进行递归
        segment(nums, center + 1, right);
        // 合并
        merge(nums, left, center, right);
    }
}

/**
 * 两两归并排好序的数组（2路归并）
 *
 * @param nums   带排序数组对象
 * @param left   左边数组的第一个索引
 * @param center 左数组的最后一个索引，center + 1右数组的第一个索引
 * @param right  右数组的最后一个索引
 */
private static void merge(int[] nums, int left, int center, int right) {
    int[] tmpArray = new int[right - left + 1];
    int leftIndex = left;   //左数组第一个元素的索引
    int rightIndex = center + 1;   //右数组第一个元素索引
    int tmpIndex = 0;    //临时数组索引

    // 把较小的数先移到新数组中
    while (leftIndex <= center && rightIndex <= right) {
        if (nums[leftIndex] <= nums[rightIndex]) {
            tmpArray[tmpIndex++] = nums[leftIndex++];
        } else {
            tmpArray[tmpIndex++] = nums[rightIndex++];
        }
    }

    // 把左边剩余的数移入数组
    while (leftIndex <= center) {
        tmpArray[tmpIndex++] = nums[leftIndex++];
    }

    // 把右边边剩余的数移入数组
    while (rightIndex <= right) {
        tmpArray[tmpIndex++] = nums[rightIndex++];
    }

    // 把新数组中的数覆盖nums数组
    /*for (int i = 0; i < tmpArray.length; i++) {
        nums[begin + i] = tmpArray[i];
    }*/
    //可以优化成下面的写法
    System.arraycopy(tmpArray, 0, nums, left, tmpArray.length);
}

 

非递归：

public static void main(String[] args) {
    int[] nums = {6, 5, 3, 8, 1, 7, 2, 9, 4};
    for (int i = 1; i <= nums.length; i *= 2) {
        for (int j = 0; j + i <= nums.length; j += i * 2) {
            //Math.min 的目的是处理 整个待排序数组为奇数的情况
            merge(nums, j, j + i - 1, Math.min(j + 2 * i - 1, nums.length - 1));
        }
    }
    System.out.println(Arrays.toString(nums));
}

/**
 * 两两归并排好序的数组（2路归并）
 *
 * @param nums   带排序数组对象
 * @param left   左边数组的第一个索引
 * @param center 左数组的最后一个索引，center + 1右数组的第一个索引
 * @param right  右数组的最后一个索引
 */
private static void merge(int[] nums, int left, int center, int right) {
    int[] tmpArray = new int[right - left + 1];
    int leftIndex = left;   //左数组第一个元素的索引
    int rightIndex = center + 1;   //右数组第一个元素索引
    int tmpIndex = 0;    //临时数组索引

    // 把较小的数先移到新数组中
    while (leftIndex <= center && rightIndex <= right) {
        if (nums[leftIndex] <= nums[rightIndex]) {
            tmpArray[tmpIndex++] = nums[leftIndex++];
        } else {
            tmpArray[tmpIndex++] = nums[rightIndex++];
        }
    }

    // 把左边剩余的数移入数组
    while (leftIndex <= center) {
        tmpArray[tmpIndex++] = nums[leftIndex++];
    }

    // 把右边边剩余的数移入数组
    while (rightIndex <= right) {
        tmpArray[tmpIndex++] = nums[rightIndex++];
    }

    // 把新数组中的数覆盖nums数组
    /*for (int i = 0; i < tmpArray.length; i++) {
        nums[begin + i] = tmpArray[i];
    }*/
    //可以优化成下面的写法
    System.arraycopy(tmpArray, 0, nums, left, tmpArray.length);
}

 

参考链接：

[1].http://www.cnblogs.com/yulinfeng/p/7072163.html
[2].https://www.cnblogs.com/yulinfeng/p/7078661.html?utm_source=itdadao&utm_medium=referral
[3].https://blog.csdn.net/lll1204019292/article/details/52346199
[4].https://www.jianshu.com/p/39dd1d9b491d