美文网首页
归并排序

归并排序

作者: 木木禾木 | 来源:发表于2021-06-13 00:17 被阅读0次

原理:将原序列划分为有序的n个序列,然后利用归并算法进行合并,合并之后即为有序序列。
要点:分治,归并

   private static void sortMerge(int[] array, int childLength) {
        System.out.println("分割数组,并对各个子数组排序:");
        //将原数组array分割线成长度为childLength的多个子数组
        int childArrayLength = array.length / childLength + (array.length % childLength == 0 ? 0 : 1);
        //记录各个子数组的起始位置和归并标记位 [start, end, mergeIndex]
        int[][] indexStartEnd = new int[childArrayLength][3];
        int index = 0;
        int start = 0;
        while (start < array.length) {
            int end = start + childLength - 1;
            if (end > array.length - 1) {
                end = array.length - 1;
            }
            //对子数组进行排序
            sortBubble(array, start, end);
            printArray(String.format(Locale.getDefault(), "start = %2d , end = %2d : ", start, end), array);
            indexStartEnd[index] = new int[]{start, end, start};
            start = end + 1;
            index++;
        }

        System.out.println("归并各个子数组:");
        int[] result = new int[array.length];
        for (int i = 0; i < result.length; i++) {
            boolean isMinSetValue = false;
            int minIndex = 0;
            int min = 0;
            int minPosition = 0;
            for (index = 0; index < indexStartEnd.length; index++) {
                if (indexStartEnd[index][2] <= indexStartEnd[index][1]) {
                    if (!isMinSetValue || array[indexStartEnd[index][2]] < min) {
                        minPosition = indexStartEnd[index][2];
                        min = array[minPosition];
                        minIndex = index;
                        isMinSetValue = true;
                    }
                }
            }
            indexStartEnd[minIndex][2] = indexStartEnd[minIndex][2] + 1;
            result[i] = array[minPosition];
            printArray(String.format(Locale.getDefault(), "min = %2d , minPosition = %2d : ", min, minPosition), result);
        }
    }

将数组array分割成长度为6的多个子数组,运行结果:

原数组:  34  42  13  56  45  22   8  50  73   5  43  84  34  81  73  27  44  59  26  91
归并排序:
分割数组,并对各个子数组排序:
第  0 趟 :   34  13  42  45  56  22   8  50  73   5  43  84  34  81  73  27  44  59  26  91
第  1 趟 :   13  34  42  45  56  22   8  50  73   5  43  84  34  81  73  27  44  59  26  91
第  2 趟 :   13  34  42  45  56  22   8  50  73   5  43  84  34  81  73  27  44  59  26  91
start =  0 , end =  5 :   13  34  42  45  56  22   8  50  73   5  43  84  34  81  73  27  44  59  26  91
第  6 趟 :   13  34  42  45  56  22   8  50   5  43  73  84  34  81  73  27  44  59  26  91
第  7 趟 :   13  34  42  45  56  22   8   5  43  50  73  84  34  81  73  27  44  59  26  91
第  8 趟 :   13  34  42  45  56  22   5   8  43  50  73  84  34  81  73  27  44  59  26  91
第  9 趟 :   13  34  42  45  56  22   5   8  43  50  73  84  34  81  73  27  44  59  26  91
start =  6 , end = 11 :   13  34  42  45  56  22   5   8  43  50  73  84  34  81  73  27  44  59  26  91
第 12 趟 :   13  34  42  45  56  22   5   8  43  50  73  84  34  73  27  44  81  59  26  91
第 13 趟 :   13  34  42  45  56  22   5   8  43  50  73  84  34  27  44  73  81  59  26  91
第 14 趟 :   13  34  42  45  56  22   5   8  43  50  73  84  27  34  44  73  81  59  26  91
第 15 趟 :   13  34  42  45  56  22   5   8  43  50  73  84  27  34  44  73  81  59  26  91
start = 12 , end = 17 :   13  34  42  45  56  22   5   8  43  50  73  84  27  34  44  73  81  59  26  91
第 18 趟 :   13  34  42  45  56  22   5   8  43  50  73  84  27  34  44  73  81  59  26  91
start = 18 , end = 19 :   13  34  42  45  56  22   5   8  43  50  73  84  27  34  44  73  81  59  26  91
归并各个子数组:
min =  5 , minPosition =  6 :    5   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
min =  8 , minPosition =  7 :    5   8   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
min = 13 , minPosition =  0 :    5   8  13   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
min = 26 , minPosition = 18 :    5   8  13  26   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
min = 27 , minPosition = 12 :    5   8  13  26  27   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
min = 34 , minPosition =  1 :    5   8  13  26  27  34   0   0   0   0   0   0   0   0   0   0   0   0   0   0
min = 34 , minPosition = 13 :    5   8  13  26  27  34  34   0   0   0   0   0   0   0   0   0   0   0   0   0
min = 42 , minPosition =  2 :    5   8  13  26  27  34  34  42   0   0   0   0   0   0   0   0   0   0   0   0
min = 43 , minPosition =  8 :    5   8  13  26  27  34  34  42  43   0   0   0   0   0   0   0   0   0   0   0
min = 44 , minPosition = 14 :    5   8  13  26  27  34  34  42  43  44   0   0   0   0   0   0   0   0   0   0
min = 45 , minPosition =  3 :    5   8  13  26  27  34  34  42  43  44  45   0   0   0   0   0   0   0   0   0
min = 50 , minPosition =  9 :    5   8  13  26  27  34  34  42  43  44  45  50   0   0   0   0   0   0   0   0
min = 56 , minPosition =  4 :    5   8  13  26  27  34  34  42  43  44  45  50  56   0   0   0   0   0   0   0
min = 22 , minPosition =  5 :    5   8  13  26  27  34  34  42  43  44  45  50  56  22   0   0   0   0   0   0
min = 73 , minPosition = 10 :    5   8  13  26  27  34  34  42  43  44  45  50  56  22  73   0   0   0   0   0
min = 73 , minPosition = 15 :    5   8  13  26  27  34  34  42  43  44  45  50  56  22  73  73   0   0   0   0
min = 81 , minPosition = 16 :    5   8  13  26  27  34  34  42  43  44  45  50  56  22  73  73  81   0   0   0
min = 59 , minPosition = 17 :    5   8  13  26  27  34  34  42  43  44  45  50  56  22  73  73  81  59   0   0
min = 84 , minPosition = 11 :    5   8  13  26  27  34  34  42  43  44  45  50  56  22  73  73  81  59  84   0
min = 91 , minPosition = 19 :    5   8  13  26  27  34  34  42  43  44  45  50  56  22  73  73  81  59  84  91

相关文章

  • 排序算法

    约定 选择排序 冒泡排序 插入排序 希尔排序 归并排序1. 归并方法2. 自顶向下归并排序3. 自底向上归并排序 ...

  • 排序二:归并、快排

    文章结构 归并排序 快速排序 源码 1. 归并排序 1.1 什么是归并排序 归并排序的思想是:将待排序的区间平分成...

  • java归并排序

    归并排序什么是归并排序:图解归并排序归并排序有两种实现方式,一是基于递归,而是基于迭代1)基于递归的归并排序: 基...

  • 算法—排序篇2

    1、归并排序(Merging Sort) 归并排序(Merging Sort): 就是利用归并的思想实现排序⽅法....

  • 常见的排序算法(2)

    要点 快速排序 归并排序 1.快速排序 2.归并排序

  • 排序算法之归并排序

    归并排序(Merge Sort) 归并排序是利用归并的思想实现排序的方式,该算法采用的是经典的分治算法 归并排序过...

  • 算法 第二章第二部分笔记

    各种排序算法的性能特点 选择排序 插入排序 希尔排序 归并排序 本地归并排序 自底向上的归并排序 快速排序 三向切...

  • 归并排序(二路归并排序)

    归并排序的思路 归并排序是通过“归并”操作完成排序的,将两个或者多个有序子表归并成一个子表。归并排序是“分治法”的...

  • 算法排序之归并排序和快速排序

    归并排序和快速排序用的都是分治的思想,用递归的编程技巧来实现.咱们先来看归并排序. 归并排序 归并排序的核心思想就...

  • 基于左闭右开的乱序数组归并排序 2020-04-24(未经允许,

    归并排序代码模板 递归形式思路:二分nums数组后对nums的归并排序 = 对左侧数组归并排序+对右侧数组归并排序...

网友评论

      本文标题:归并排序

      本文链接:https://www.haomeiwen.com/subject/caiueltx.html