归并排序递归实现

 1 /*
 2  * 归并排序递归实现
 3  * 简介:将两个(或两个以上)有序表合并成一个新的有序表 即把待排序序列分为若干个子序列,每个子序列是有序的。
 4  * 然后再把有序子序列合并为整体有序序列
 5  * 时间复杂度为O(nlogn)
 6  *
 7  * */
 8
 9 import java.util.Arrays;
10
11 public class MegerSort {
12     public int[] sort(int[] k,int low,int high)
13     {
14         int center=(low+high)/2;  //获取数组中间位置
15         if(low<high)
16         {
17             sort(k,low,center);   //对左边进行递归调用
18             sort(k,center+1,high);//对右边进行递归调用
19             merge(k,low,center,high); //先分成两半,然后再归并起来
20         }
21         return k;
22     }
23     public void merge(int[] k,int low, int center,int high)
24     {
25         int[] temp=new int[high-low+1]; //声明一个可以存放一定大小的数组,
26         int i=low; //左边起始位置
27         int j=center+1; //右边起始位置
28         int m=0;
29         //对左右数组进行比较排序
30         while(i<=center && j<=high)
31         {
32             if(k[i]<k[j])
33             {
34                 temp[m++]=k[i++];
35             }
36             else
37             {
38                 temp[m++]=k[j++];
39             }
40         }
41         while(i<=center)  //当左边数组还没遍历完时,直接添加在后面
42         {
43             temp[m++]=k[i++];
44
45         }
46         while(j<=high)//当右边数组还没遍历完时,直接添加在后面
47         {
48             temp[m++]=k[j++];
49
50         }
51          // 把新数组中的数覆盖k数组
52         for(int n=0;n<temp.length;n++)
53         {
54             k[n+low]=temp[n];
55         }
56     }
57
58     public static void main(String[] args) {
59         // TODO Auto-generated method stub
60         MegerSort sort = new MegerSort();
61         int[] A ={5,7,2,9,8,6,1,3,4,0};
62         System.out.println("排序前的顺序:");
63         System.out.println(Arrays.toString(A));
64         sort.sort(A, 0, A.length-1);
65         System.out.println();
66         System.out.println("使用归并排序后的顺序为");
67         System.out.println(Arrays.toString(A));
68
69     }
70
71 }
时间: 2024-07-30 01:38:24

归并排序递归实现的相关文章

归并排序 - 递归非递归实现java

1.归并排序思想: 以2路归并为例,一个有n个记录的序列可以看作n个长度为1的有序子序列,将其两两合并成n/2(向上取整)个长度为2或1的有序序列,当有奇数个记录时为1,重复归并,直到得到一个长度为n的有序序列. 2.归并排序的复杂度: 递归:时间复杂度O(nlongn),空间复杂度O(n+longn) 非递归:时间复杂度O(nlongn),空间复杂度O(n) 所以用到归并排序,还是优先考虑非递归吧.  3.递归实现 1 public void mergeSort1(int[] data){ 2

归并排序--递归

直接看代码 package com.lm.digui; public class GuiBinSort { public static void main(String[] args) { int[] arr = {1, 2, 3, 5, 8}; System.out.println(guibinNumber(arr, 0, arr.length - 1, 5)); } private static int guibinNumber(int[] arr, int low, int high, i

递归和迭代两种方式实现归并排序(Java版)

递归版 package MergeSort; import Utils.SortUtils; /** * 归并排序递归版 * @author liguodong */ public class Demo02 { public static void mergeSort(int[] a){ mSort(a, a, 0, a.length-1); } /** * * @param SR为待排序的数据 * @param TR1为排序之后的数据 * @param s * @param t */ publ

算法基础:分治模式,归并排序ΘΘΘΘΘΘ知识小结

1.分治模式在每层递归时都有三个步骤:分解,解决,合并 2.归并排序算法完全遵循分治模式: 分解:分解待排序的n个元素的序列成各具n/2个元素的两个子序列 解决:使用归并排序递归的排序两个子序列 合并:合并两个已排序的子序列以产生已排序的答案 3.分析分治算法所需要的时间计算: 假设T(n)是规模为n的一个问题的运行时间,若问题足够小,如对某个常量c,n≦c,则直接求解需要常量时将,我们将其写作Θ(1).假设吧原问题分解成a个子问题,每个子问题的规模是原问题的1/b(对归并排序,a和b都为2,然

【算法导论】归并排序

递归与分治 许多有用的算法在结构上是递归的:为了解决一个给定的问题,算法一次或多次递归地调用其自身以解决紧密相关的若干子问题.这些算法典型地遵循分治法的思想:将原问题分解为几个规模较小但类似于原问题的子问题,递归地求解这些子问题,然后再合并这些子问题的解来建立原问题的解. 分治模式在每层递归时都有三个步骤: 分解原问题为若干子问题,这些子问题是原问题的规模较小的实例. 解决这些子问题,递归地求解各子问题.然而,若子问题的规模足够小,则直接求解. 合并这些子问题的解成原问题的解. 归并排序 归并排

排序算法——归并排序

归并排序是分治法的典型举例. 分治法的思想是,将原有问题分解为几个规模较小但类似于原问题的子问题,递归的求解这些子问题,然后再合并这些子问题的解来建立原问题的解. 分治模式在每层递归时都有三个步骤: 分解原问题为若干子问题,这些子问题是原问题的规模较小的实例. 解决这些子问题,递归地求解各子问题.然而,若子问题的规模足够小,则直接求解. 合并这些子问题的解成原问题的解. 归并排序算法完全遵循分治模式.直观上其操作如下: 分解:分解待排序的n个元素的序列成各具n/2个元素的两个子序列. 解决:使用

算法练习——归并排序

归并排序的基本思路利用分治方法解决. 分治模式的每一层递归都有三个思路: 分解原问题为若干子问题,这些子问题是原问题的规模较小的实例.解决这些子问题,递归地求解各子问题.然而,若子问题的规模足够小,则直接求解.合并这些子问题的解成原问题的解. 归并排序算法完全遵循分治模式.直观上其操作如下:分解:分解待排序的拧个元素的序列成各具n/2个元素的两个子序列.解决:使用归并排序递归地排序两个子序列.合并:合并两个已排序的子序列以产生已排序的答案.当待排序的序列长度为1时,递归"开始回升",(

排序算法(Java语言)——归并排序

归并排序mergesort中基本的操作是合并两个已排序的表.因为这两个表已排序,所以若将输出放到第三个表中,则该算法可以通过对输入数据一趟排序完成.基本的合并算法是取两个输入数组A和B,一个输出数组C,以及3个计数器Actr.Bctr.Cctr,他们初始置于对应数组的开始端.A[Actr]和B[Bctr]中的较小者被拷贝到C的下一个位置,相关的计数器向前推进一步.当两个输入表有一个用完的时候,则将另一个表中剩余部分拷贝到C中. 合并另个已排序的表的时间显然是线性的,因为最多进行N-1次比较,其中

排序——归并排序(分治法)

在写归并排序之前,首先谈一谈分治的思想, 所谓分治:就是将一个比较复杂的问题分解为若干个规模较小的但是类似原问题的子问题,(解决)递归地求解这些这些子问题,再合并这些子问题的解来求解原问题 可分为三步: 分解:将原问题分解为若干个规模较小的但是类似原问题的子问题 求解:递归地求解这些这些子问题,然而若子问题规模足够小,可直接求解 合并:合并这些子问题的解来求解原问题 接下来,终于可以写归并排序了 分解:将一个有N个数的数列分解为2个分别有n/2个数的2个子数列 求解:使用归并排序递归地分别排序两