归并排序——java

import java.util.Arrays;
public class Cao46
{
/**
* @归并排序
*
* 三个指针:两个指针最初位置分别为两个已经排序序列的起始位置,第三个指针两个序列的中间位置
* 两个方法:一个是递归方法
* 一个是合并方法,每一趟将最多含2的n次方个元素的单元排序
* 工作原理:

1、申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列

2、设定两个指针,最初位置分别为两个已经排序序列的起始位置

3、比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置

4、重复步骤3直到某一指针达到序列尾

5、将另一序列剩下的所有元素直接复制到合并序列尾
*/
public static void main(String[] args)
{
int[] array={1,6,3,2,5,9,4,7};
sort(array,0,array.length-1);
System.out.println(Arrays.toString(array));//打印数组

}
public static void sort(int[] array, int left, int right) {
if (left<right)
{
//找出中间索引
int center=(left+right)/2;
//对左边数组进行递归
sort(array,left,center);
//对右边数组进行递归
sort(array,center+1,right);
//合并
merge(array,left,center,right);

}
}
public static void merge(int[] array, int left, int mid, int right) {
int[] temp = new int[right - left + 1];
int l = left;// 左指针
int r = mid + 1;// 右指针
int k = 0;//临时数组指针

// 把较小的数先移到新数组中
while (l<= mid && r <= right)
{
if (array[l] < array[r])
{
temp[k++] = array[l++];
}
else
{
temp[k++] = array[r++];
}
}

// 把左边剩余的数移入数组
while (l <= mid)
{
temp[k++] = array[l++];
}

// 把右边边剩余的数移入数组
while (r <= right)
{
temp[k++] = array[r++];
}
// 把新数组中的数覆盖array数组
System.arraycopy(temp, 0, array, left, right - left + 1);
}
}

时间: 2024-11-09 00:36:14

归并排序——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实现

二路归并排序:其核心思想时将问题一分为二,并递归调用一分为二方法,使问题分割到不能再分各的原子问题,然后再归并,从实现原子问题开始,层层向上归并,最终解决整体问题.即所谓"分而治之,万流归一" 二路归并排序的时间复杂度计算如下: 参考资料:算法导论------递归算法的时间复杂度求解: 二路归并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). 每次我们选择的值刚好是中间值,这样,数组才可以被等分. 第一

归并排序-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