归并排序-JAVA实现

  1 package com.iloveu.xxx;
  2
  3 public class MergeSort {
  4
  5     static final int SIZE = 15;
  6
  7     static void mergeOne(int a[],int b[],int n,int len)
  8     {
  9         int i,j,k,s,e;
 10         s=0;
 11         while(s+len<n){
 12             e = s+2*len-1;
 13             if(e>=n){//最后一段可能少于len个节点
 14                 e = n -1;
 15             }
 16             //相邻有序段合并
 17             k=s;
 18             i=s;
 19             j=s+len;
 20             while(i<s+len && j<=e){//如果两个有序表都未结束时,循环比较
 21                 if(a[i]<=a[j]){//如果较小的元素复制到数组b中
 22                     b[k++]=a[i++];
 23                 }else{
 24                     b[k++]=a[j++];
 25                 }
 26             }
 27             while(i<s+len){//未合并的部分复制到数组b中
 28                 b[k++]=a[i++];
 29             }
 30             while(j<=e){//未合并的部分复制到数组b中
 31                 b[k++]=a[j++];
 32
 33             }
 34             s=e+1;//下一对有序段中左段的开始下标
 35         }
 36         if(s<n){//将剩余的一个有序段从数组a中复制到数组b中
 37             for(;s<n;s++){
 38                 b[s] = a[s];
 39             }
 40
 41         }
 42     }
 43
 44     static void mergeSort(int a[],int n)//合并排序
 45     {
 46         int h,count,len,f;
 47
 48         count = 0;//排序步骤
 49         len = 1;//有序序列的长度
 50         f = 0;//变量f作标志
 51
 52         int[] p = new int[n];
 53         while(len<n){
 54             if(f==1){//交替在a和p之间合并
 55                 mergeOne(p,a,n,len);//p合并到a
 56             }else{
 57                 mergeOne(a,p,n,len);//a合并到p
 58             }
 59             len = len*2;//增加有序序列长度
 60             f=1-f;//使f值在0和1之间切换
 61
 62             count++;
 63             System.out.printf("第"+count+"步排序结果:");//输出每步排序的结果
 64             for(h=0;h<SIZE;h++){
 65                 System.out.printf(" "+a[h]);
 66
 67             }
 68             System.out.printf("\n");
 69         }
 70         if(f==1){//如果进行了排序
 71             for(h=0;h<n;h++){//将内存p中的数据复制回数组a
 72                 a[h]=p[h];
 73             }
 74         }
 75     }
 76
 77     public static void main(String[] args) {
 78         // TODO Auto-generated method stub
 79         int[] shuzu=new int[SIZE];
 80         int i;
 81
 82         for(i=0;i<SIZE;i++){
 83             shuzu[i] = (int) (100+Math.random()*(100+1));//初始化数组
 84         }
 85
 86         System.out.print("排序前的数组为:\n");//输出排序前的数组
 87         for(i=0;i<SIZE;i++){
 88             System.out.print(shuzu[i]+" ");
 89             }
 90             System.out.print("\n");
 91
 92             mergeSort(shuzu,SIZE);//排序操作
 93
 94             System.out.print("排序后的数组为:\n");
 95             for(i=0;i<SIZE;i++){
 96                 System.out.print(shuzu[i]+" ");//输出排序后的数组
 97                 try {
 98                     Thread.sleep(1000);
 99                 } catch (InterruptedException e) {
100                     // TODO Auto-generated catch block
101                     e.printStackTrace();
102                 }
103             }
104             System.out.print("\n");
105         }
106
107
108 }

package com.iloveu.xxx;
public class MergeSort {static final int SIZE = 15;static void mergeOne(int a[],int b[],int n,int len){int i,j,k,s,e;s=0;while(s+len<n){e = s+2*len-1;if(e>=n){//最后一段可能少于len个节点e = n -1;}//相邻有序段合并k=s;i=s;j=s+len;while(i<s+len && j<=e){//如果两个有序表都未结束时,循环比较if(a[i]<=a[j]){//如果较小的元素复制到数组b中b[k++]=a[i++];}else{b[k++]=a[j++];}}while(i<s+len){//未合并的部分复制到数组b中b[k++]=a[i++];}while(j<=e){//未合并的部分复制到数组b中b[k++]=a[j++];}s=e+1;//下一对有序段中左段的开始下标}if(s<n){//将剩余的一个有序段从数组a中复制到数组b中for(;s<n;s++){b[s] = a[s];}}}static void mergeSort(int a[],int n)//合并排序{int h,count,len,f;count = 0;//排序步骤len = 1;//有序序列的长度f = 0;//变量f作标志int[] p = new int[n];while(len<n){if(f==1){//交替在a和p之间合并mergeOne(p,a,n,len);//p合并到a}else{mergeOne(a,p,n,len);//a合并到p}len = len*2;//增加有序序列长度f=1-f;//使f值在0和1之间切换count++;System.out.printf("第"+count+"步排序结果:");//输出每步排序的结果for(h=0;h<SIZE;h++){System.out.printf(" "+a[h]);}System.out.printf("\n");}if(f==1){//如果进行了排序for(h=0;h<n;h++){//将内存p中的数据复制回数组aa[h]=p[h];}}}
public static void main(String[] args) {// TODO Auto-generated method stubint[] shuzu=new int[SIZE];int i;for(i=0;i<SIZE;i++){shuzu[i] = (int) (100+Math.random()*(100+1));//初始化数组}System.out.print("排序前的数组为:\n");//输出排序前的数组for(i=0;i<SIZE;i++){System.out.print(shuzu[i]+" ");}System.out.print("\n");mergeSort(shuzu,SIZE);//排序操作System.out.print("排序后的数组为:\n");for(i=0;i<SIZE;i++){System.out.print(shuzu[i]+" ");//输出排序后的数组try {Thread.sleep(1000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}System.out.print("\n");}

}

时间: 2024-11-09 00:59:08

归并排序-JAVA实现的相关文章

归并排序 求逆序数 链表的归并排序 多线程归并排序 java

import java.util.Scanner; public class Main { private static int count=0; public static void mergesort(int a[],int low,int high) { if(low<high) { int mid=(low+high)>>1; mergesort(a,low,mid); mergesort(a,mid+1,high); merge(a,low,mid,high); } } pri

归并排序——java

import java.util.Arrays;public class Cao46{ /** * @归并排序 * * 三个指针:两个指针最初位置分别为两个已经排序序列的起始位置,第三个指针两个序列的中间位置 * 两个方法:一个是递归方法 * 一个是合并方法,每一趟将最多含2的n次方个元素的单元排序 * 工作原理: 1.申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列 2.设定两个指针,最初位置分别为两个已经排序序列的起始位置 3.比较两个指针所指向的元素,选择相对小的元素放

二路归并排序java实现

二路归并排序:其核心思想时将问题一分为二,并递归调用一分为二方法,使问题分割到不能再分各的原子问题,然后再归并,从实现原子问题开始,层层向上归并,最终解决整体问题.即所谓"分而治之,万流归一" 二路归并排序的时间复杂度计算如下: 参考资料:算法导论------递归算法的时间复杂度求解: 二路归并java实现: 1 public class MergeSort { 2 3 public static void main(String[] args) { 4 int [] array =

归并排序Java

思想:http://www.cnblogs.com/jillzhang/archive/2007/09/16/894936.html Java代码:http://blog.csdn.net/middlekingt/article/details/8446552 先收藏这个,后面自己写

归并排序-java

排序-归并排序 基本思想:是指将两个或两个以上的有序表合并成一个新的有序表. 具体步骤: (1首先将整个表看成是n个有序子表,每个子表的长度为1. (2)然后两两归并,得到n/2个长度为2的有序子表. (3)然后再两两归并,直至得到一个长度为n的有序表为止. 平均时间:O(nlogn) 最好情况:O(nlogn) 最坏情况:O(n2) 辅助空间:O(n) 稳定性:稳定 适用场景:n比较大时 代码实现: 1 public static void mergeSort(int[] list) { 2

leetcode23 多个拍好序的链表进行归并排序 (java版本)

题目: Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity 思路1: 依次归并排序,首先归并前两个,然后归并完成的链表依次和剩下的链表进行归并排序 时间复杂度为O(m*n) 代码: public static ListNode mergeKLists1(ListNode[] lists){ int len = lists.length; if(len =

归并排序 java语言实现

package sort; import java.util.Random; public class MergeSort { @SuppressWarnings("unused") public boolean initTestArray(int[] testArray) {// 初始化testArray if (testArray == null) return false; Random random = new Random(); for (int i = 0; i <

归并排序java实现

public static void main(String[] args) { int arr[]={2,4,6,8,14,1,3,5,9,11}; merge(arr, 0, arr.length-1); for(int i=0;i<arr.length;i++){ System.out.print(arr[i]+" "); } } //递归排序,分治法,自顶向下,递归分割数组,最终归并 public static void merge(int [] arr,int star

数据结构归并排序java实现

思想: 假设初始序列右n个记录,首先将这n个记录看成n个有序的子序列,每个子序列的长度为1,然后两两归并,得到n/2向上取整 个长度为2(n为奇数时,最后一个序列的长度为1)的有序子序列.在此基础上,在对长度为2的有序子序列进行两两归并,得到若干个长度为4的有序子序列.如此重复,直至得到一个长度为n的有序序列为止. 稳定性:稳定 时间复杂度计算: 数组的大小是2的幂,这样分下去始终可以被2整除.假设为2的k次方,即k=log2(n). 每次我们选择的值刚好是中间值,这样,数组才可以被等分. 第一