精华内容
下载资源
问答
  • 归并排序java

    2017-11-03 11:05:39
    归并排序采用分治思想,递归的缩小规模来进行排序。先分后合,分治减少了比较次数,而合并仅仅只是移动元素。在java中,进行一次元素比较可能是昂贵的,但是移动元素则是省时的(仅仅是引用的赋值,而不是对象的拷贝...
    • 归并排序采用分治思想,递归的缩小规模来进行排序。先分后合,分治减少了比较次数,而合并仅仅只是移动元素。在java中,进行一次元素比较可能是昂贵的,但是移动元素则是省时的(仅仅是引用的赋值,而不是对象的拷贝)

    • 归并排序,运行时间是O (N log N)
      事实上,它就是标准类库中泛型排序使用的算法
      (C++中主要用的是快速排序)

    • 归并排序使用所有排序算法中最少的比较次数

    java实现:

    public class MergeSort {
    
        public static <AnyType extends Comparable<? super AnyType>> void mergeSort(AnyType[] a) {
            // 新建临时数组,保存归并结果
            AnyType[] tmpArray = (AnyType[]) new Comparable[a.length];
            mergeSort(a, tmpArray, 0, a.length - 1);
        }
    
        /**分而治之,递归**/
        private static <AnyType extends Comparable<? super AnyType>> void mergeSort(
                AnyType[] a, AnyType[] tmpArray, int left, int right) {
            // 最后一种情况,只有两个数,有效程序只有最后一行,merge的时候就比较了两数的大小并排好序
            if (left < right) {
                // 截成两段分别排序,之后再合并
                int center = (left + right) / 2;
                mergeSort(a, tmpArray, left, center);
                mergeSort(a, tmpArray, center + 1, right);
                merge(a, tmpArray, left, center + 1, right);
            }
        }
    
        /**合并**/
        private static <AnyType extends Comparable<? super AnyType>> void merge(
                AnyType[] a, AnyType[] tmpArray, int leftPos, int rightPos, int rightEnd) {
            int leftEnd = rightPos - 1;
            int tmpPos = leftPos;
            int numElements = rightEnd - leftPos + 1;
            while (leftPos <= leftEnd && rightPos <= rightEnd) {
                if (a[leftPos].compareTo(a[rightPos]) <= 0) {
                    tmpArray[tmpPos++] = a[leftPos++];
                } else {
                    tmpArray[tmpPos++] = a[rightPos++];
                }
            }
            while (leftPos <= leftEnd) {
                tmpArray[tmpPos++] = a[rightPos++];
            }
            while (rightPos <= rightEnd) {
                tmpArray[tmpPos++] = a[leftPos++];
            }
            for (int i=0; i<numElements; i++, rightEnd--) {
                a[rightEnd] = tmpArray[rightEnd];
            }
        }
    }
    展开全文
  • 归并排序java实现.pdf

    2021-09-14 16:40:53
    归并排序java实现.pdf
  • 归并排序 java

    2013-04-27 16:38:56
    归并排序 归并排序是另一类不同的排序方法,所谓归并,就是把两个或者两个以上的有序表合并成一个新的有序表的过程。 归并排序的基本思想: 将一个含有n个序列的有序表看成是n个长度为1的有序表,然后两两归并,得到...

    归并排序

    归并排序是另一类不同的排序方法,所谓归并,就是把两个或者两个以上的有序表合并成一个新的有序表的过程。

    归并排序的基本思想:

    将一个含有n个序列的有序表看成是n个长度为1的有序表,然后两两归并,得到[n/2]个长度为2的有序表,然后再两两归并,直到得到一个长度为n的有序表为止。

    下面是归并排序的一个简单的例子:

    初始值 【49】 【38】 【65】 【97】 【76】 【13】 【27】

    看成由长度为1的7个子序列组成

    第一次合并之后 【38 49】 【65 97】 【13 76】 【27】

    看成由长度为1或2的4个子序列组成

    第二次合并之后 【38 49 65 97】 【13 27 76】

    看成由长度为4或3的2个子序列组成

    第三次合并之后 【13 27 38 49 65 76 97】

    归并排序的JAVA实现:

    public class MergeSort {

    /**
    * 归并排序 先将初始的序列表看成是n个长度为1的有序表 (1)定义指针i,指向第一个序列表的第一个元素
    * (2)定义指针j,指向第二个序列表的第一个元素 (3)比较i,j指向的元素大小,若前者大,将后者插入到新表中 否则,把前者插入到后表中
    * (4)直到取完第一个序列表或者第二个序列表为止
    *
    * @param args
    */

    public static void main(String[] args) {
    // TODO Auto-generated method stub

    int[] num = { 51, 38, 49, 27, 62, 05, 16 };
    int[] num1 = new int[7];
    num = mergesort(num, 0, num.length - 1, num1);

    for (int i : num) {
    System.out.print(i + " ");
    }

    }

    private static int[] mergesort(int[] num, int s, int t, int[] num1) {

    int m;
    int[] num2 = new int[t + 1];
    if (s == t)
    num1[s] = num[s];

    else {
    m = (s + t) / 2;
    mergesort(num, s, m, num2);//左半部分递归调用
    mergesort(num, m + 1, t, num2);//右半部分递归调用
    merg(num2, s, m, t, num1);// 由num2去归并,返回的值放到num1中,num1赋新值,其实就是更新num2,然后让num2再去归并,返回新的num1

    }

    return num1;
    }

    //有序表的合并

    private static void merg(int[] num, int l, int m, int n, int[] num1) {
    System.out.print("l=" + l + " m=" + m + " n=" + n);
    System.out.println();
    int i, j, k;
    i = l;
    j = m + 1;
    k = l;
    while (i <= m && j <= n) {
    if (num[i] < num[j])
    num1[k++] = num[i++];
    else {
    num1[k++] = num[j++];
    }
    }

    while (i <= m) {
    num1[k++] = num[i++];
    }
    while (j <= n) {
    num1[k++] = num[j++];
    }

    }

    }

    性能分析:

    时间复杂度:

    由于归并的趟数,等于树的高度Logn,每趟归并需要移动记录n次,因此归并排序的时间复杂度为nlogn.

    空间复杂度:

    从上面的算法可以看出,需要一个辅助空间num2,其长度等于n,所以归并排序的辅助空间为O(n).

    稳定性:

    归并排序不涉及到交换,因此它是一种稳定的排序算法。

    归并排序是典型的用空间去换取时间,它的时间开销比简单排序要优越,但需要与序列等长的辅助空间。

    展开全文
  • 归并排序Java实现

    2019-08-26 11:11:52
    归并排序Java实现 public class MergeSort { public static void sort(int[] a,int left, int right){ if(left >= right) return; int center = (left + right) >> 1; sort(a, left...

    归并排序Java实现

    public class MergeSort {
    
        public static void sort(int[] a,int left, int right){
            if(left >= right) return;
            int center = (left + right) >> 1;
            sort(a, left, center);
            sort(a, center + 1, right);
            merge(a, left, center, right);
        }
        public static void merge(int[] data, int left, int center, int right){
            int [] tmpArr = new int[right + 1]; //辅助数组
            int mid = center + 1;
            int index = left;
            int tmp = left;
    
            while(left <= center && mid <= right){ //左右比较将较小的加入到临时数组
                tmpArr[index++] = (data[left] <= data[mid]) ? data[left++] : data[mid++];
            }
            // 将剩余的尾部数据加入到临时数组
            while(left <= center){
                tmpArr[index++] = data[left++];
            }
            while(mid <= right){
                tmpArr[index++] = data[mid++];
            }
            // 将临时数组中的数据加入到原数组中
            for(int i=tmp; i<= right; i++)
                data[i] = tmpArr[i];
    		/* 展示递归效果
    		for(int b : data)
                System.out.print(b+" ");
            System.out.println();
    		*/ 
        }
        //测试程序
        public static void main(String[] args) {
    	    int[] a = {49, 38, 65, 97, 76, 13, 27, 50};
    	    sort(a, 0, a.length -1 );
    	    for(int b : a)
                System.out.print(b+" ");
        }
    }
    
    
    展开全文
  • 归并排序 java语言

    2015-03-16 12:20:20
    归并排序 java描述
    <pre name="code" class="java">/*
     * 归并排序算法
     */
    public class MergeSort {
    	final static int MAX=0x7FFFFFFF;
    	
    	public static void main(String[] args) {
    		int []a = {5,4,8,7,1,3,2,6,12,13,19,25,45,17};
    		mergeSort(a,0,a.length-1);
    		System.out.print("排序后数组:");
    		for(int i:a) {
    			System.out.print(i+" ");
    		}
    	}
    
    	private static void mergeSort(int[] a, int p, int r) {
    		if(p < r) {
    			int q = (p+r)/2;
    			mergeSort(a,p,q);
    			mergeSort(a,q+1,r);
    			mergeIn(a,p,q,r);		
    		}	
    	}
    
    	private static void mergeIn(int[] a, int p, int q, int r) {
    		int n1=q-p+1;
    		int n2=r-q;
    		int[] L = new int[n1+1];
    		int[] R = new int[n2+1];
    		
    		for(int i=0;i<n1;i++) {
    			L[i]=a[p+i];
    		}
    		
    		for(int i=0;i<n2;i++) {
    			R[i]=a[q+i+1];
    		}
    		
    		L[n1] = MAX;
    		R[n2] = MAX;
    		
    		int i=0,j=0;
    		for(int k=p; k<=r; k++) {
    			if(L[i]<=R[j]) {
    				a[k]=L[i];
    				i++;	
    			}
    			else {
    				a[k] = R[j];
    				j++;
    			}
    		}	
    	}
    }


     
    

    运行结果为:

    1 2 3 4 5 6 7 8 12 13 17 19 25 45 


     
    
    展开全文
  • 文章目录堆排序java代码实现单元测试归并排序java代码实现单元测试 堆排序 java代码实现 package csdn.dreamzuora.sort; import java.util.List; /** * Title: 抽象出排序类 * Description: * * @version 1.0 ...
  • 归并排序 Java实现

    2017-09-07 22:50:03
    Java实现的归并排序
  • 八大排序之堆排序–归并排序 java 基本思想  归并排序是利用归并的思想实现的排序方法,该算法采用经典的分治策略(分治法将问题分(divide)成一些小的问题然后递归求解,而治(conquer)的阶段则将分的阶段得到的各...
  • 归并排序java实现

    2020-04-11 15:25:45
    归并排序 1、原理 归并排序是一种概念上最简单的排序算法,归并排序是基于分治法的。归并排序将待排序的元素序列分成两个长度相等的子序列,为每一个子序列排序,然后再将他们合并成一个子序列。合并两个子序列的...
  • 归并排序 java 实现实现思路 将序列每相邻的两个元素进行归并,得到 n/2 个序列,每个序列包含两个元素; 再将上述序列归并,每个序列有4个元素 重复步骤2 最后一步是对两个序列归并,这两个序列的总长度是原数组的...
  • 归并排序java示例

    2018-11-08 09:03:34
    归并排序是建立在归并操作上的一种有效的排序算法,该算法采用分治法的思想。分:将待排序序列拆分成一个个子序列。治:将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。 ...
  • 归并排序—>分治 归并排序归并排序—>分治背景归并原理与过程原理:过程图形展示模板代码模板讲解归并例子完整java代码 背景 归并排序是十大排序之一 十大排序: 归并原理与过程 原理: 取中值,将数组分成...
  • 归并排序Java源代码

    2009-05-10 20:44:25
    利用分治法思想实现归并排序Java语言描述。
  • 自然归并排序java

    2017-11-06 13:19:37
    自然合并的核心主要是一个Pass函数,这个函数中设置了一个array数组,来存放每一组有序元素的起始元素的下标,最后再将最后一个元素的下标+1存放为array数组的最后一个元素,这样,在后面的合并实现中会显现出这样记录的...
  • 单链表归并排序java

    2017-09-05 23:04:24
    该算法是采用分治法(Divide and Conquer)的一个非常典型的应用,归并排序将两个已排序的表合并成一个表。 归并排序基本原理 通过对若干个有序结点序列的归并来实现排序。  所谓归并是指将若干个已排好序的...
  • 1、归并排序算法思想 归并排序主要是二路归并排序。 二路归并排序的基本思想是:设数组a中存放了n个数据元素,初始时把它们看成是n个长度为1的有序子数组,然后从第一个子数组开始,把相临的子数组两两合并,得到n/2...
  • * 归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法将已有序的子序列合并,最后得到完全有序的序列。 * 归并排序是稳定排序,速度仅次于快速排序 * 时间复杂度为O(nlogn) * 空间复杂度为O(n)...
  • 归并排序Java代码实现

    千次阅读 2019-06-01 15:41:00
    归并排序 和选择排序一样,归并排序的性能不受输入数据的影响,但表现比选择排序好的多,因为始终都是O(n log n)的时间复杂度。代价是需要额外的内存空间。 归并排序是建立在归并操作上的一种有效的排序算法。该...
  • 外部归并排序Java实现

    2019-08-02 11:28:55
    NULL 博文链接:https://yeelor.iteye.com/blog/1964843
  • 归并排序 归并排序采用的是分治(divide-and-conquer)法思想。 1.基本思想: 将待排序元素分成大小大致相同的2个子集合,分别对2个子集合进行排序,最终将排好序的子集合合并成为所要求的排好序的集合。 2.执行过程:...
  • 1 冒泡排序 思想:每一个元素和后一个元素比较,如果前者更大,互换位置,这样,一轮后,最大值为最后一个;接下来找次大值,重复操作。 package leetCode; import java.util.Arrays; import java.util....
  • 归并排序 归并操作(merge),也叫归并算法,指的是将两个顺序序列合并成一个顺序序列的方法。 如 设有数列{6,202,100,301,38,8,1} 初始状态:6,202,100,301,38,8,1 第一次归并后:{6,202},{100,301},{8,38},{...
  • 快速排序(Quicksort) 是一种排序算法,平均时间复杂度为:O(n log n),最坏需要 O(n²),但很少见,快速排序之所以叫快速排序,就是因为它比一般的排序算法要快。 快速排序使用了分而治之的思想,步骤如下: 选择...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,136
精华内容 17,654
关键字:

归并排序java

java 订阅