自然归并

最新推荐文章于 2021-02-20 02:40:50 发布
最新推荐文章于 2021-02-20 02:40:50 发布
阅读量204 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43573607/article/details/103645910
版权 
package Test1;

import java.util.Arrays;

public class Class1 {

    public static void main(String [] agrs){
        /**
        所有代码都需要再次改动，暂定此版本
         */
    int []a= new int[]{1, 5, 2, 3, 6, 0, 7, 4, 8,-1,9};
    int []temp=new int[a.length ];
//    System .out .println(a.length ) ;
    int []index= new int[a.length];
    int []NatureGroupingNumber=new int [1];
    int[] roundnumber = new int[1];
    GetPiont(a ,index ,NatureGroupingNumber ,a.length );
    /*
  System .out .println(Arrays .toString(a) );
   System .out .println(Arrays .toString(index)) ;
    System .out .println(NatureGroupingNumber[0]) ;
 */
    MergeSort(a,temp,index,NatureGroupingNumber,roundnumber);
    System .out .println(Arrays .toString(a) );

    }

    public static void Merge(int[] a, int[] temp,int l,int m, int r) {
        int i=l;
        int j=m+1;
        int k=l;
        while(i<=m&&j<=r){
            /**
             if(a[i++]<a[j++])
             原先写成了a[i++]跟a[j++],没注意看后面已经有a[i++],a[j++]导致数组溢出
             */
            if(a[i]<a[j])
                temp[k++]=a[i++];
            else
                temp[k++]=a[j++];
        }
        if(i>m)
            for(int q=j;q<=r;q++)
                temp[k++]=a[q];
         else
             for (int q = i; q <=m; q++)
                 temp[k++] =a[q];
    }

    public static void MergePass(int []a,int []index,int []roundernumber,int []NatureGroupingNumber,int []temp) {
        int i=0;
        /**
         while(i <= (NatureGroupingNumber[0] -roundernumber[0] *2))效果等同；
         当第一轮合并的时候，roundnumber=1;
         i=0
         i<8/(2*1)
         当第二轮合并的时候，roundnumber=1;
         它需要指向下一个的left,所以它变成了i=roundnumber*2+i=3;
     xxxxx    写while语句，当i<NatureGroupingNumber/(roundnumber*2),则可以继续循环下去，意思是左端点不大于中间
         的端点
                写while语句，只是控制循环的次数
                因为roundnumber是*2的增长的，所以为了表示右端点，所以i=i+roundnumber*2;
                不能将循环while写成：
         i<=(NatureGroupingNumber[0]/roundnumber/2)因为 i=i+roundnumber*2；
         i从0 开始，所以while条件里面 NatureGroupingNumber-roundernumber*2;剪掉一次合并
         */
        while(i <= (NatureGroupingNumber[0] -roundernumber[0] *2)){//AAAA
        int r=(i+2*roundernumber [0])<NatureGroupingNumber [0]?index [i+2*roundernumber[0] ]:a.length ;
        Merge(a,temp,index[i],index[i+roundernumber [0]]-1,r-1);
        // i=i+1;
        i=i+2*roundernumber [0];
        System.out .println("i:"+i) ;
        }/**
         原先一开始顺序错了
         比如说6组NatureGroupingNumber
         第一次是6组 两两都合并成功；所以最后i=NatureGroupingNumber=6；
         第二次只能合并前4组，所以i=4<NatureGroupingNumber=6，还剩2组不能合并，就只能暂时将它们后面两组赋值给已经合并好的组
         第三次合并，i=0，此时也不满足while语句的条件  所以i+roundnumber<NatureGroupingNumber,所以就让它们直接合并

        */
        /*if (i + roundernumber[0] >= NatureGroupingNumber[0]) {
            if(i<NatureGroupingNumber[0] ){
                for(int j=index [i];j<a.length ;j++)
                    temp[j]=a[j];

            }
        } else {
            Merge(a, temp, index[i], index[i + roundernumber[0] * 2], a.length - 1);
        }*/
        if(i<NatureGroupingNumber[0] )
        {
            for(int j=index [i];j<a.length ;j++)
                temp[j]=a[j];
        }
       if(i+roundernumber[0] <NatureGroupingNumber [0])
        {
            Merge(a,temp,index [i],index [i+roundernumber [0]]-1,a.length -1);
            System.out.println(11111);
        }
    }

    public static void MergeSort(int []a, int []temp, int[] index, int[] NatureGroupingNumber, int[] roundnumber) {
        roundnumber [0]=1;
        /**
        Exception in thread "main" java.lang.ArithmeticException: / by zero
        先前报有此错误，是因为没有赋值语句，导致分母为0
        所谓的分母指的是A处
         */
        while (roundnumber [0]<NatureGroupingNumber[0] ){
            /*
            第一次roundnumber=1;
            第二次roundnumber=2;
            roundnumber不是次数，是当前次数需要合并的组数；
             */
          //  System .out .println(roundnumber [0]/2+":"+roundnumber [0]) ;
            MergePass(a,index ,roundnumber ,NatureGroupingNumber ,temp) ;
            roundnumber[0]+=roundnumber[0];
          //   System .out .println(roundnumber [0]/2+":"+roundnumber [0]) ;
            MergePass(temp,index ,roundnumber ,NatureGroupingNumber,a) ;
            roundnumber[0]+=roundnumber[0];
        }

    }


    public static void GetPiont(int[] a, int []index,int []NatureGroupingNumber,int c){
        int j=0;
        index[j++]=0;
        for(int i=0;i<c-1;i++) {
            if(a[i]>a[i+1])
            {index[j++]=i+1;}
        }
        NatureGroupingNumber[0]=j;
        System .out .println(j) ;
    }

}

上面那个是对的，下面那个是理解有错误的…

package Test1;

import java.util.Arrays;

public class Class1 {

    public static void main(String [] agrs){
        /*
        所有代码都需要再次改动，暂定此版本
         */
    int []a= new int[]{1, 5, 2, 3, 6, 0, 7, 4, 8};
    int []temp=new int[a.length ];
//    System .out .println(a.length ) ;
    int []index= new int[a.length];
    int []NatureGroupingNumber=new int [1];
    int[] roundnumber = new int[1];
    GetPiont(a ,index ,NatureGroupingNumber ,a.length );
    /*
  System .out .println(Arrays .toString(a) );
   System .out .println(Arrays .toString(index)) ;
    System .out .println(NatureGroupingNumber[0]) ;
 */
    MergeSort(a,temp,index,NatureGroupingNumber,roundnumber);
    System .out .println(Arrays .toString(a) );

    }

    public static void Merge(int[] a, int[] temp,int l,int m, int r) {
        int i=l;
        int j=m+1;
        int k=l;
        while(i<=m&&j<=r){
            /**
             if(a[i++]<a[j++])
             原先写成了a[i++]跟a[j++],没注意看后面已经有a[i++],a[j++]导致数组溢出
             */
            if(a[i]<a[j])
                temp[k++]=a[i++];
            else
                temp[k++]=a[j++];
        }
        if(i>m)
            for(int q=j;q<=r;q++)
                temp[k++]=a[q];
         else
             for (int q = i; q <=m; q++)
                 temp[k++] =a[q];
    }

    public static void MergePass(int []a,int []index,int []roundernumber,int []NatureGroupingNumber,int []temp) {
        int i=0;
        /**
         while(i <= (NatureGroupingNumber[0] -roundernumber[0] *2))效果等同；
         当第一轮合并的时候，roundnumber=1;
         i=0
         i<8/(2*1)
         当第二轮合并的时候，roundnumber=1;
         它需要指向下一个的left,所以它变成了i=roundnumber*2+i=3;
         写while语句，当i<NatureGroupingNumber/(roundnumber*2),则可以继续循环下去，意思是左端点不大于中间
         的端点
         */
        while(i <= (NatureGroupingNumber[0] /(roundernumber[0] * 2))){//AAAA
        int r=(i+2*roundernumber [0])<NatureGroupingNumber [0]?index [i+2*roundernumber[0] ]:a.length ;
        Merge(a,temp,index[i],index[i+roundernumber [0]]-1,r-1);
        // i=i+1;
        i=i+2*roundernumber [0];
        }
        if (i + roundernumber[0] >= NatureGroupingNumber[0]) {
            if(i<NatureGroupingNumber[0] ){
                for(int j=index [i];j<a.length ;j++)
                    temp[j]=a[j];

            }
        } else {
            Merge(a, temp, index[i], index[i + roundernumber[0] * 2], a.length - 1);
        }
    }

    public static void MergeSort(int []a, int []temp, int[] index, int[] NatureGroupingNumber, int[] roundnumber) {
        roundnumber [0]=1;
        /*
        Exception in thread "main" java.lang.ArithmeticException: / by zero
        先前报有此错误，是因为没有赋值语句，导致分母为0
        所谓的分母指的是A处
         */
        while (roundnumber [0]<NatureGroupingNumber[0] ){
            /*
            第一次roundnumber=1;
            第二次roundnumber=2;
            roundnumber不是次数，是当前次数需要合并的组数；
             */
            System .out .println(roundnumber [0]) ;
            MergePass(a,index ,roundnumber ,NatureGroupingNumber ,temp) ;
            roundnumber[0]+=roundnumber[0];
            System .out .println(roundnumber [0]) ;
            MergePass(temp,index ,roundnumber ,NatureGroupingNumber,a) ;
            roundnumber[0]+=roundnumber[0];
        }

    }


    public static void GetPiont(int[] a, int []index,int []NatureGroupingNumber,int c){
        int j=0;
        index[j++]=0;
        for(int i=0;i<c-1;i++) {
            if(a[i]>a[i+1])
            {index[j++]=i+1;}
        }
        NatureGroupingNumber[0]=j;
        System .out .println(j) ;
    }

}

代码需要修改，很多地方加了我对程序的理解，我自己觉得可以100%明白；
主要是我刚学java还不太懂调用方法，因为我只知道它是拷贝传值。。。
然鹅，传了一个值过去他又没法改变；
然后我又知道数组是地址存的，所以我所有的数据都是数组…
这是我照着原来大佬写的代码

---------------------------------------------END-------------------------------------------------------

短腿跑得慢
关注
自然归并排序java版
11-06
自然合并的核心主要是一个Pass函数,这个函数中设置了一个array数组,来存放每一组有序元素的起始元素的下标,最后再将最后一个元素的下标+1存放为array数组的最后一个元素,这样,在后面的合并实现中会显现出这样记录的原因.(其中具体实现可以参考代码,重点是理解代码中的注释)
C#归并排序的实现方法(递归,非递归,自然归并)
09-05
在C#中，归并排序可以通过递归、非递归以及自然归并三种方式实现。以下是这三种实现方法的详细解释： 1. **递归归并排序**： 递归归并排序是归并排序最直观的实现方式。它首先将数组分成两半，分别对这两半进行...
自然归并排序
yy1348046572的博客
01-06 362
#include&lt;iostream&gt; using namespace std; int Search(int *a, int *b, int n); void Merge(int *a, int left, int mid, int right); void MergeSort(int *a, int *b, int num,int n); void MergePass(int ...
自然归并排序（非递归）
qq_44971979的博客
10-02 606
算法思想：将一个数组内的本来有序的子段用标记点标记出来，再将每两个子段合并。（剩余的标记点如果不足以两两合并需要例外考虑） 具体样例： 样例1 输入： 6 6 5 4 3 2 1 输出： 1 2 3 4 5 6 样例2 输入： 5 5 4 3 2 1 输出： 1 2 3 4 5 源代码： #include<stdio.h> #define N 100 //输入数组的值 int scan_f(int n, int *s) { for(int i = 0;i<n;i++)
自然归并排序算法（C语言）
weixin_44903715的博客
09-23 858
**自然**归并排序指的是对数组先进行一次线性扫描，得到自然排好序的子数段{4，8}，{7}，{1，5，6}，{2}。在对其进行两两合并成更大的排好序的数组。
自然合并排序
HP的博客
03-18 3974
自然合并排序是合并排序算法的一种改进, 对于初始给定的数组, 通常存在多个长度大于1的已自然排好序的子数组段. 例如, 若数组a中元素为{1, 5, 2, 3, 6, 0, 7, 4, 8}, 则自然排好序的子数组段有{1, 5}, {2, 3, 6}, {0, 7}, {4, 8}. 用一次对数组a的线性扫描就足以找出所有这些排好序的子数组段. 然后将相邻的排好序的子数组段两两合并,构成更大的排好
C++ 使用指针自然归并排序算法示例
03-15
**指针自然归并排序算法**是一种高效的排序方法，它基于分治策略，将大问题分解为小问题来解决。在C++编程中，指针是实现这种算法的关键工具，因为它们可以灵活地指向和操作内存中的数据。下面将详细解释这种算法的...
归并排序（递归、非递归、自然归并排序）
Walker-C
03-30 450
算法思想：   归并排序是分治法的典型应用，其思想是不断地将两个有序的数组合并为一个有序数组。 递归实现    #include &lt;stdio.h&gt; void Merge(int a[], int left, int m, int right); void MergeSortAux(int a[], int left, int right); void MergeSort(i...
算法学习————自然归并算法（c/c++）
weixin_44628242的博客
09-19 873
自然归并算法实现（c/c++） 前言：由于归并算法的资料已经很多了，本文主要讲述的是自然归并算法 自然归并算法VS归并算法 自然归并算法实际上是归并算法的一个变型。 例如在下文实例代码中的数组a中的元素为{6,1,9,4,5,8,7,2,3}，在数组中的自然排序为{6}，{1,9}，{4,5,8}，{7}，{2,3}。接着根据自然排序将相邻的排好序的子数组进行归并排序，这就是自然归并排序算法的基本思想。 通常情况下，自然归并算法需要合并的次数比归并算法要少，而在极端情况下，如：对于已经排好序的n元数组。自然
归并排序的优化--自然归并排序
Zyfgoup的博客
03-27 568
不知道怎么将这个算法思想表达的更好，也不知道自己的理解的是否对 黑体的注释是普通的自然归并，从相邻长度为1的子数组段进行合并也就是一开始将每两个相邻元素进行归并，然后再相邻四个元素左右两组都有序的合并成4个有序的........自下向上不断往上归并直到有序 /* * 自然合并排序是合并排序算法的一种改进. 自然合并排序: * 对于初始给定的数组,通常存在多个长度大于1的已自然排...
算法 -- 归并排序之自然排序
LemonLee‘s Blog
10-26 5609
定义: 归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个典型应用.应该将已经有序的子序列合并,得到完全有序的序列:即先使每个子序列有序,再使子序列段间有序.若将两个有序表合并成一个有序表,称为二路归并. [摘录于维基百科] 无论哪一种归并算法的实现,它都需要用到一个MergeArray函数实现两个有序数组的合并.如下:
Natural Merge Sort(自然归并排序)
weixin_30896763的博客
04-15 252
This is a Natural Merge Sort program from my textbook. It works, but I don't think it's good. // Natural merge sort program in the textbookpublic class NaturalMergeSortProgram { public s...
分治法----普通归并排序和自然归并排序（java实现）
weixin_44392808的博客
02-02 782
1、普通归并排序 归并排序算法的基本思想是将待排序元素分成大小大致相同的两个子序列，分别对这两个字序列进行排序，最终将排好序的子序列合并为所要求的序列。归并排序算法完全依照下面3个步骤进行。 （1）分解。将n个元素分成各含n/2个元素的子序列。 （2）求解。用归并排序对两个子序列递归地排序。 （3）合并。合并两个已经排好序的子序列以得到排序结果。 核心代码如： void MergeS...
java实现归并算法
smartboy的专栏
05-05 888
package mydata; public class MyMergeSort { /** * * 1.递归拆分 * 2.合并 * 归并排序 先将初始的序列表看成是n个长度为1的有序表 * (1)定义指针i,指向第一个序列表的第一个元素 * (2)定义指针j，指向第二个序列表的第一个元素 * (3)比较i,j指向的元素大小，若前者大，将后者插入到新表中 否
归并算法（Java版）
memory_cood的博客
03-05 980
归并算法，正如他的名字一样，递归算法+合并算法，所以想要学习这个算法，可以从两方面先入手，一就是先学习递归算法，了解递归思想。二肯定就是合并算法；这两个算法并不难学，不知道的可以先查一下资料。 还是先看递归算法把，代码很简单，没什么技术含量，重点是他的结束条件，也就是递归基该怎么取得问题 合并算法看下面两张图片，行数太多没法截在一起，请见谅： 好了。主要的代码就在上面了，下面给个
归并java_归并排序Java实现
weixin_35795512的博客
02-20 147
packagepractice;import edu.princeton.cs.algs4.*;/** 归并排序* 时间复杂度O(NlgN) N为数组长度* 归并排序在小数组上表现并不好可以用插入排序代替*/public classTestMain {public static voidmain(String[] args) {int[] a = new int[20];for (int i = ...
自然归并排序 c++ (原创)
weixin_30851867的博客
03-14 332
　　今天复习算法, 自然归并算法令我挺感兴趣,结果网上找到的基本都不怎么准确,下面通过自己的一些修改,贴出一份正确的代码! 　　自然归并中,有一些已经自然排好序的序列,我们称其为有序子序列! 1 void NaturalMergeSort(T aSrc[], int n) 2 { 3 　　T *pTmp = new T[n]; 4 　　int aiBreakPoint[n]; //包含各...
自然归并排序：分治策略与算法比较
自然归并排序是一种基于分治策略的高效排序算法，它在计算机科学中被广泛应用。该算法主要针对具有潜在自然有序子序列的数组进行操作，通过找到这些子序列并将它们合并成一个更大的有序序列，直至整个数组完全有序。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值