稳定的归并排序

1. 思路

把整个数组分成不同的小段

2. 过程

每次分割为两部分,log2n次。
每次内部 使用一个help数组,原左部分和原右部分左侧相比,谁小谁放到help中,对应部分起始位置++,
知道一方全部放入,另一方直接加入到help数组中,再更新到原数组上。

3. 代码

   public static void mergeProcess(int[] arr, int L, int R) {
        if (L == R) {
            return;
        }
        int mid = L + (R - L) / 2;
        mergeProcess(arr, L, mid);
        mergeProcess(arr, mid + 1, R);
        merge(arr, L, mid, R);
    }

    /**
     * 归并排序,非递归实现
     * 外循环,步长两倍递增,O(logN)
     * 内循环,L为每组左组起点,左组范围[L,M] 右组范围[M+1,N]
     * M=L+step-1
     * N=Math.min(M+step,N-1)
     *
     * @param arr 1 2 5 9 7 2 3 1
     *            0 1 2 3 4 5 6 7
     *            L
     */
    public static void mergeProcess2(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        int N = arr.length;
        int step = 1;
        //当步长不足N
        while (step < N) {
            //每组左边界
            int L = 0;
            //如果左边界> arr.length了,就退出
            while (L < N) {
                //每一次范围分为左右组  左组[L,M],右组[M+1,N]
                //[0,7]   [0,3][4,7] 步长为4  M=L+step-1
                //        [L,M][M+1,N] N=Math.min(M+step,N-1)

                int M = L + step - 1;
                if (M > N) {
                    break;
                }
                //每组右边界
                int R = Math.min(M + step, N - 1);
                merge(arr, L, M, R);
                //新的左边界=右边界+1
                L = R + 1;
            }
            if (step > N / 2) {
                //步长超过一半就退出
                break;
            }
            step *= 2;
        }
    }


    public static void merge(int[] arr, int L, int mid, int R) {
        //辅助数组
        int[] help = new int[R - L + 1];
        //当前数组的位置
        int helpIndex = 0;
        //原数组左部分起始位置
        int leftIndex = L;
        //原数组右部分起始位置 mid就不行
        int rightIndex = mid + 1;

        //当左右两侧都还有数组,没有越界时
        while (leftIndex <= mid && rightIndex <= R) {
            help[helpIndex++] = arr[leftIndex] < arr[rightIndex] ? arr[leftIndex++] : arr[rightIndex++];
        }

        //当右边越界
        while (leftIndex <= mid) {
            help[helpIndex++] = arr[leftIndex++];
        }

        //当左边越界
        while (rightIndex <= R) {
            help[helpIndex++] = arr[rightIndex++];
        }
        helpIndex = 0;
        //排好序的部分归还原数组
        for (int i = L; i <= R; i++) {
            arr[i] = help[helpIndex++];
        }
    }

4. 时间复杂度O(n*log2n)

根据master公式计算,O=O(n)+2O(n/2)=O(n*logn)

在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值