java中归并排序的代码 java归并排序算法

java 归并排序算法问题

int[]

创新互联公司成立十年来，这条路我们正越走越好，积累了技术与客户资源，形成了良好的口碑。为客户提供网站制作、成都网站制作、网站策划、网页设计、域名注册、网络营销、VI设计、网站改版、漏洞修补等服务。网站是否美观、功能强大、用户体验好、性价比高、打开快等等，这些对于网站建设都非常重要，创新互联公司通过对建站技术性的掌握、对创意设计的研究为客户提供一站式互联网解决方案，携手广大客户，共同发展进步。

result=

new

int

[high-low+1];

复杂进eclipse测试了下，没有问题。不知道你想干什么……

java实现归并排序问题

public void mySort(int low,int high){

int lo=low;

int hi=high;

if (lo=hi) {

return;

}else{

boolean flag=false;

while (lohi) {

if (arrs[lo]arrs[hi]) {

int temp=arrs[lo];

arrs[lo]=arrs[hi];

arrs[hi]=temp;

flag=!flag;

}else{

if (flag) {

lo++;

}else{

hi--;

}

lo--;

hi++;

mySort(low,lo);

mySort(hi,high);

}

这里是递归加二分法(排序的方法) 希望能帮到你！！望~~点赞

归并排序的示例代码

归并排序原理

归并排序具体工作原理如下（假设序列共有n个元素）：

将序列每相邻两个数字进行归并操作（merge)，形成floor(n/2)个序列，排序后每个序列包含两个元素

将上述序列再次归并，形成floor(n/4)个序列，每个序列包含四个元素

重复步骤2，直到所有元素排序完毕

示例代码

Go语言 func mergeSort(r []int) []int { length := len(r) if length = 1 { return r } num := length / 2 left := mergeSort(r[:num]) right := mergeSort(r[num:]) return merge(left, right)}func merge(left, right []int) (result []int) { l, r := 0, 0 for l len(left) r len(right) { if left[l] right[r] { result = append(result, left[l]) l++ } else { result = append(result, right[r]) r++ } } result = append(result, left[l:]...) result = append(result, right[r:]...) return}Java语言 package　algorithm;public　class　MergeSort　{ //　private　static　long　sum　=　0; /** 　*　pre 　*　二路归并　*　原理：将两个有序表合并和一个有序表　*　/pre 　*　　*　@param　a 　*　@param　s 　*　第一个有序表的起始下标　*　@param　m 　*　第二个有序表的起始下标　*　@param　t 　*　第二个有序表的结束小标　*　　*/ private　static　void　merge(int[]　a,　int　s,　int　m,　int　t)　{ int[]　tmp　=　new　int[t　-　s　+　1]; int　i　=　s,　j　=　m,　k　=　0; while　(i　　m　　j　=　t)　{ if　(a[i]　=　a[j])　{ tmp[k]　=　a[i]; k++; i++; }　else　{ tmp[k]　=　a[j]; j++; k++; } } while　(i　　m)　{ tmp[k]　=　a[i]; i++; k++; } while　(j　=　t)　{ tmp[k]　=　a[j]; j++; k++; } System.arraycopy(tmp,　0,　a,　s,　tmp.length); } /** 　*　　*　@param　a 　*　@param　s 　*　@param　len 　*　每次归并的有序集合的长度　*/ public　static　void　mergeSort(int[]　a,　int　s,　int　len)　{ int　size　=　a.length; int　mid　=　size　/　(len　　1); int　c　=　size　　((len　　1)　-　1); //　-------归并到只剩一个有序集合的时候结束算法-------// if　(mid　==　0) return; //　------进行一趟归并排序-------// for　(int　i　=　0;　i　　mid;　++i)　{ s　=　i　*　2　*　len; merge(a,　s,　s　+　len,　(len　　1)　+　s　-　1); } //　-------将剩下的数和倒数一个有序集合归并-------// if　(c　!=　0) merge(a,　size　-　c　-　2　*　len,　size　-　c,　size　-　1); //　-------递归执行下一趟归并排序------// mergeSort(a,　0,　2　*　len); } public　static　void　main(String[]　args)　{ int[]　a　=　new　int[]　{　4,　3,　6,　1,　2,　5　}; mergeSort(a,　0,　1); for　(int　i　=　0;　i　　a.length;　++i)　{ System.out.print(a[i]　+); } }}Python语言 def MergeSort(lists): if len(lists) = 1: return lists num = int( len(lists)/2 ) left = MergeSort(lists[:num]) right = MergeSort(lists[num:]) return Merge(left, right)def Merge(left,right): r, l=0, 0 result=[] while llen(left) and rlen(right): if left[l] right[r]: result.append(left[l]) l += 1 else: result.append(right[r]) r += 1 result += right[r:] result+= left[l:] return resultprint MergeSort([1, 2, 3, 4, 5, 6, 7, 90, 21, 23, 45])C语言 #include stdlib.h#include stdio.hvoid Merge(int sourceArr[],int tempArr[], int startIndex, int midIndex, int endIndex){ int i = startIndex, j=midIndex+1, k = startIndex; while(i!=midIndex+1 j!=endIndex+1) { if(sourceArr[i] = sourceArr[j]) tempArr[k++] = sourceArr[j++]; else tempArr[k++] = sourceArr[i++]; } while(i != midIndex+1) tempArr[k++] = sourceArr[i++]; while(j != endIndex+1) tempArr[k++] = sourceArr[j++]; for(i=startIndex; i=endIndex; i++) sourceArr[i] = tempArr[i];}//内部使用递归void MergeSort(int sourceArr[], int tempArr[], int startIndex, int endIndex){ int midIndex; if(startIndex endIndex) { midIndex = (startIndex + endIndex) / 2; MergeSort(sourceArr, tempArr, startIndex, midIndex); MergeSort(sourceArr, tempArr, midIndex+1, endIndex); Merge(sourceArr, tempArr, startIndex, midIndex, endIndex); }}int main(int argc, char * argv[]){ int a[8] = {50, 10, 20, 30, 70, 40, 80, 60}; int i, b[8]; MergeSort(a, b, 0, 7); for(i=0; i8; i++) printf(%d , a[i]); printf(\n); return 0;}PHP语言 //merge函数将指定的两个有序数组(arr1arr2,)合并并且排序//我们可以找到第三个数组,然后依次从两个数组的开始取数据哪个数据小就先取哪个的,然后删除掉刚刚取过///的数据functional_merge($arrA,$arrB){ $arrC = array(); while(count($arrA) count($arrB)){ //这里不断的判断哪个值小,就将小的值给到arrC,但是到最后肯定要剩下几个值, //不是剩下arrA里面的就是剩下arrB里面的而且这几个有序的值,肯定比arrC里面所有的值都大所以使用 $arrC[] = $arrA['0'] $arrB['0'] ? array_shift($arrA) : array_shift($arrB); } returnarray_merge($arrC, $arrA, $arrB);}//归并排序主程序functional_merge_sort($arr){ $len=count($arr); if($len = 1) return $arr;//递归结束条件,到达这步的时候,数组就只剩下一个元素了,也就是分离了数组 $mid = intval($len/2);//取数组中间 $left_arr = array_slice($arr, 0, $mid);//拆分数组0-mid这部分给左边left_arr $right_arr = array_slice($arr, $mid);//拆分数组mid-末尾这部分给右边right_arr $left_arr = al_merge_sort($left_arr);//左边拆分完后开始递归合并往上走 $right_arr = al_merge_sort($right_arr);//右边拆分完毕开始递归往上走 $arr=al_merge($left_arr, $right_arr);//合并两个数组,继续递归 return $arr;}$arr = array(12, 5, 4, 7, 8, 3, 4, 2, 6, 4, 9);print_r(al_merge_sort($arr));Pascal语言 program　mergesort_1;const　maxn=7;type　arr=array[1..maxn]　of　integer;var　a,b,c:arr;i:integer;procedure　merge(r:arr;l,m,n:integer;varr2:arr);var　i,j,k,p:integer;begin　i:=l;　j:=m+1;　k:=l-1;　while　(i=m)　and　(j=n)　do　begin　k:=k+1;　if　r[i]=r[j]　then　begin　r2[k]:=r[i];　i:=i+1　end　else　begin　r2[k]:=r[j];　j:=j+1;　end　end;　if　i=m　then　for　p:=i　to　m　do　begin　k:=k+1;　r2[k]:=r[p];　end;　if　j=n　then　for　p:=j　to　n　do　begin　k:=k+1;　r2[k]:=r[p];　end;end;procedure　mergesort(var　r,r1:arr;s,t:integer);var　k:integer;c:arr;begin　if　s=t　then　r1[s]:=r[s]　else　begin　k:=(s+t)div2;　mergesort(r,c,s,k);　mergesort(r,c,k+1,t);　merge(c,s,k,t,r1)　end;end;begin　write('Enterdata:');　for　i:=1　to　maxn　do　read(a[i]);　mergesort(a,b,1,maxn);　for　i:=1　to　maxn　do　write(b[i]:9);　writeln;end.//============================================program　mergesort_2;const　max=100000;var　a,r:array[1..max]　of　long　int;n,i:long　int;procedure　msort(s,t:longint);var　m,i,j,k:long　int;begin　if　s=t　then　exit;　m:=(s+t)div2;　msort(s,m);　msort(m+1,t);　i:=s;　j:=m+1;　k:=s;　while　(i=m)　and　(j=t)　do　begin　if　a[i]a[j]　then　begin　r[k]:=a[i];　inc(i);　inc(k);　end　else　begin　r[k]:=a[j];　inc(j);　inc(k);　end;　end;　while　i=m　do　begin　r[k]:=a[i];　inc(i);　inc(k);　end;　while　j=t　do　begin　r[k]:=a[j];　inc(j);　inc(k);　end;　for　i:=s　to　t　do　a[i]:=r[i];end;begin　readln(n);　for　i:=1　to　n　do　read(a[i]);　msort(1,n);　for　i:=1　to　n　do　writeln(a[i]);end.Basic语言 Sub MergeSort(Array() As Integer, First As Integer, Last As Integer)Dim mid As Integer = 0If firstlast Then mid = (first+last)\ 2MergeSort(Array, first, mid);MergeSort(Array, mid+1, last);Merge(Array, first, mid, last);End IfEnd Sub/*以下示例代码实现了归并操作。array[]是元素序列，其中从索引p开始到q位置，按照升序排列，同时，从(q+1)到r也已经按照升序排列，merge()函数将把这两个已经排序好的子序列合并成一个排序序列。结果放到array中。*//*** 0 = p = q r, subarray array[p..q] and array[q+1..r] are already sorted.* the merge() function merges the two sub-arrays into one sorted array.*/void Merge(int array[], int p, int q, int r){ int i,k; int begin1,end1,begin2,end2; int* temp = (int*)malloc((r-p+1)*sizeof(int)); begin1 = p; end1 = q; begin2 = q+1; end2 = r; k = 0; while((begin1 = end1)( begin2 = end2)) { if(array[begin1] = array[begin2]){ temp[k] = array[begin1]; begin1++; } else { temp[k] = array[begin2]; begin2++; } k++; } while(begin1=end1 || begin2=end2) { if(begin1=end1) { temp[k++] = array[begin1++]; } if(begin2=end2) { temp[k++] = array[begin2++]; } } for (i = 0; i =(r - p); i++) array[p+i] = temp[i]; free(temp);}JavaScript语言

使用递归的代码如下。优点是描述算法过程思路清晰，缺点是使用递归，mergeSort()函数频繁地自我调用。长度为n的数组最终会调用mergeSort()函数 2n-1次，这意味着一个长度超过1500的数组会在Firefox上发生栈溢出错误。可以考虑使用迭代来实现同样的功能。 function　merge(left, right){ var　result=[]; while(left.length0 right.length0){ if(left[0]right[0]){ /*shift()方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。*/ result.push(left.shift()); }else{ result.push(right.shift()); } } return　result.concat(left).concat(right);}function　mergeSort(items){ if(items.length == 1){ return　items;}var　middle = Math.floor(items.length/2), left = items.slice(0, middle), right = items.slice(middle); return　merge(mergeSort(left), mergeSort(right));}非递归算法（C++） #includeiostream#includectime#includecstring#includecstdlibusing namespace std;/**将a开头的长为length的数组和b开头长为right的数组合并n为数组长度，用于最后一组*/void　Merge(int*　data,int　a,int　b,int　length,int　n){　int　right;　if(b+length-1 = n-1)　right = n-b;　else　right = length;　int*　temp = new　int[length+right];　int　i=0, j=0;　while(i=length-1 j=right-1){ 　if(data[a+i] = data[b+j]){ 　 temp[i+j] = data[a+i];i++; } 　else{ temp[i+j] = data[b+j]; j++; }　}　if(j == right){//a中还有元素，且全都比b中的大,a[i]还未使用　 memcpy(temp + i + j, data + a + i, (length - i) * sizeof(int));　} else if(i == length){ memcpy(temp + i + j, data + b + j, (right - j)*sizeof(int)); }　memcpy(data+a, temp, (right + length) * sizeof(int));　delete [] temp;}void　MergeSort(int*　data, int　n){　int　step = 1;　while(step n){ 　for(int　i=0; i=n-step-1; i+=2*step) 　 Merge(data, i, i+step, step, n); //将i和i+step这两个有序序列进行合并 //序列长度为step //当i以后的长度小于或者等于step时，退出　step*=2;//在按某一步长归并序列之后，步长加倍　}}int　main(){　int　n;　cinn;　int*　data = new　int[n];　if(!data)　exit(1);　int　k = n;　while(k--){　 cindata[n-k-1];　}　clock_t　s = clock();　MergeSort(data, n);　clock_t　e = clock();　k=n;　while(k--){　 coutdata[n-k-1]' ';　}　coutendl;　coutthe algorithm usede-smiliseconds.endl;　delete　data;　return　0;}二路归并

ConstFI='in.txt';FO='out.txt';MaxN=10000;TypeTIndex=Longint;TDat=Array[0..MaxN]OfTIndex;VarN:TIndex;Dat:TDat;Tmp:TDat;ProcedureMerge(L,Mid,R:TIndex);VarP1,P2:TIndex;E1,E2:TIndex;P:TIndex;I:TIndex;BeginP1:=L;P2:=Mid+1;P:=L;RepeatIf(Dat[P1]=Dat[P2])ThenBeginTmp[P]:=Dat[P1];Inc(P1);Inc(P);EndElseBeginTmp[P]:=Dat[P2];Inc(P2);Inc(P);End;Until(P1=Mid+1)Or(P2=R+1);If(P1=Mid+1)ThenBeginE1:=P2;E2:=R;EndElseBeginE1:=P1;E2:=Mid;End;ForI:=E1ToE2DoBeginTmp[P]:=Dat[I];Inc(P);End;End;ProcedureSort(L,R:TIndex);VarMid:TIndex=0;BeginMid:=(L+R)Shr1;If(LMid)ThenSort(L,Mid);If(Mid+1R)ThenSort(Mid+1,R);Merge(L,Mid,R);ForMid:=LToRDoDat[Mid]:=Tmp[Mid];End;ProcedureInit;VarI:TIndex;BeginFillChar(Dat,SizeOf(Dat),0);Readln(N);ForI:=1ToNDoRead(Dat[I]);End;ProcedureMain;BeginSort(1,N);End;ProcedureFinal;VarI:TIndex;BeginForI:=1ToNDoWrite(Dat[I],'');Writeln;End;BeginAssign(Input,FI);Assign(Output,FO);Reset(Input);Rewrite(Output);Init;Main;Final;Close(Input);Close(Output);End.

Delphi归并排序完整源代码例子： //合并子函数procedureTForm1.MergePass(vardatas:arrayofInteger;left,mid,right:Integer);vartmpArr:arrayofInteger;arrLen:Integer;i,k:Integer;begin1,begin2,end1,end2:Integer;beginarrLen:=right-left+1;SetLength(tmpArr,arrLen);begin1:=left;end1:=mid;begin2:=mid+1;end2:=right;k:=0;while((begin1=end1)and(begin2=end2))dobeginif(datas[begin1]datas[begin2])thenbegintmpArr[k]:=datas[begin1];Inc(begin1);endelsebegintmpArr[k]:=datas[begin2];Inc(begin2);end;inc(k);end;while(begin1=end1)dobegintmpArr[k]:=datas[begin1];Inc(begin1);Inc(k);end;while(begin2=end2)dobegintmpArr[k]:=datas[begin2];Inc(begin2);Inc(k);end;fori:=0to(right-left)dobegindatas[left+i]:=tmpArr[i];end;end;//排序主函数，left是数组左下标，0开始。right是数组右下标。procedureTForm1.MergeSort(vardatas:arrayofInteger;left,right:Integer);varmid:Integer;i:Integer;beginmid:=0;if(leftright)thenbeginmid:=(right+left)div2;showLog('中间索引：'+inttostr(mid));MergeSort(datas,left,mid);MergeSort(datas,mid+1,right);MergePass(datas,left,mid,right);showLog('---'+getArrayString(datas));//显示数组中间状态end;end;//调用方法：procedureTForm1.btn1Click(Sender:TObject);varinArr:array[0..9]ofInteger;beginCopyMemory(@inArr[0],@CTabls[0],SizeOf(Integer)*10);showLog('输入数据：'+getArrayString(inArr));MergeSort(inArr,0,High(inArr));showLog('输出数据：'+getArrayString(inArr));end;

JAVA归并排序算法，有两行代码看不懂

以var a = [4,2,6,3,1,9,5,7,8,0];为例子。

1.希尔排序。希尔排序是在插入排序上面做的升级。是先跟距离较远的进行比较的一些方法。

过程输出：

[4, 9] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [2, 5] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [6, 7] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [3, 8] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [1, 0] "gap:5" [4, 2, 6, 3, 0, 9, 5, 7, 8, 1] [4, 6, 0, 5, 8] "gap:2" [0, 2, 4, 3, 5, 9, 6, 7, 8, 1] [2, 3, 9, 7, 1] "gap:2" [0, 1, 4, 2, 5, 3, 6, 7, 8, 9] [0, 1, 4, 2, 5, 3, 6, 7, 8, 9] "gap:1" [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

由输出可以看到。第一轮间隔为5。依次对这些间隔的数组插入排序。

间隔为5：

间隔为2：

[4, 2, 6, 3, 0, 9, 5, 7, 8, 1] 4 6 0 5 8 2 3 9 7 1

排序后：

[0, 1, 4, 2, 5, 3, 6, 7, 8, 9]

间隔为1：

排序后：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]。

2.快速排序。把一个数组以数组中的某个值为标记。比这个值小的放到数组的左边，比这个值得大的放到数组的右边。然后再递归对左边和右边的数组进行同样的操作。直到排序完成。通常以数组的第一个值为标记。

代码:

3.归并排序。把一系列排好序的子序列合并成一个大的完整有序序列。从最小的单位开始合并。然后再逐步合并合并好的有序数组。最终实现归并排序。

合并两个有序数组的方法：

归并排序：

排序[4,2,6,3,1,9,5,7,8,0]输出：

left:4 right:2 left:6 right:3 left:1 right:9 left:5 right:7 left:8 right:0 left:2,4 right:3,6 left:1,9 right:5,7 left:0,8 right: left:2,3,4,6 right:1,5,7,9 left:0,8 right: left:1,2,3,4,5,6,7,9 right:0,8

看出来从最小的单位入手。

第一轮先依次合并相邻元素：4,2; 6,3; 1,9; 5,7; 8,0

合并完成之后变成： [2,4,3,6,1,9,5,7,0,8]

第二轮以2个元素为一个单位进行合并：[2,4],[3,6]; [1,9],[5,7]; [0,8],[];

合并完成之后变成：[2,3,4,6,1,5,7,9,0,8]

第三轮以4个元素为一个单位进行合并：[2,3,4,6],[1,5,7,9]; [0,8],[]

合并完成之后变成： [1,2,3,4,5,6,7,9,0,8];

第四轮以8个元素为一个单位进行合并： [1,2,3,4,5,6,7,9],[0,8];

合并完成。 [0,1,2,3,4,5,6,7,8,9];

归并排序详解

归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法（Divide and Conquer）的一个典型应用。

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段之间有序。将两个有序表合并成一个有序表，称为二路归并。

将待排序序列R[0...n-1]看成是n个长度为1的有序序列，将相邻的有序表成对归并，得到n/2个长度为2的有序表；将这些有序序列再次归并，得到n/4个长度为4的有序序列；如此反复，最后得到一个长度为n的有序序列。

归并排序需要做两件事：

1）分解：将序列每次折半划分

2）合并：将划分后的序列段两两合并后排序

如何合并？

在每次合并过程中，都是对两个有序的序列段进行合并，然后再排序。这两个有序的序列段分别为R[low, mid]和R[mid+1, high]，先将它们合并到一个局部的暂存数组R2中，待合并完成后再将R2复制回R中。

每次从两个段中取出一个记录进行关键字的比较，将较小者放入R2中，最后将各段中余下的部分直接复制到R2中。经过这样的过程，R2已经是一个有序的序列，再将其复制回R中，一次合并排序就完成了。

在某趟归并中，设各子表的长度为gap，则归并前R[0...n-1]中共有n/gap个有序的子表：R[0...gap-1], R[gap...2*gap-1], ... , R[(n/gap)*gap ... n-1]。

在将相邻的子表归并时，需要对表的特殊情况进行处理：

1）若子表个数为奇数，最后一个子表无须和其他子表归并（即本趟处理轮空）；

2）若子表个数为偶数，到最后一对子表中后一个子表区间的上限为n-1；

时间复杂度：归并排序的形式就是一棵二叉树，需要遍历的次数就是二叉树的深度，时间复杂度是O(nlogn)。

空间复杂度：算法处理过程中，需要一个大小为n的临时存储空间用来保存合并序列。

算法稳定性：在归并排序中，相等元素的顺序不会改变，所以它是稳定的算法。

总结：

1）时间复杂度：O(nlogn)

2）空间复杂度：O(n)

3）稳定性：稳定

4）复杂性：较复杂

1）空间复杂度考虑：选择优先级为[堆排序快速排序归并排序]。

2）稳定性考虑：应选归并排序，堆排序和快速排序都是不稳定的。

3）平均排序速度考虑：应选快速排序。

import java.util.Arrays;

/**

* 归并排序

* 效率O（nlogn），归并的最佳、平均和最糟用例效率之间没有差异，适用于排序大列表，基于分治法。

public class MergeSort {

public static void main(String[] args) {

int[] array = {9, 1, 5, 3, 4, 2, 6, 8, 7};

MergeSort merge = new MergeSort();

System.out.println("排序前:"+Arrays.toString(array));

merge.sort(array);

System.out.println("排序后:"+Arrays.toString(array));

}

private static int[] sort(int[] list){

for(int gap = 1;gap list.length; gap = 2*gap){

MergePass(list,gap,list.length);

System.out.println("gap="+gap+":"+Arrays.toString(list));

}

return list;

}

private static void MergePass(int[] arr,int gap,int length){

int i=0;

// 归并gap长度的两个相邻子表

for(i=0;i+2*gap-1 length;i = i+2*gap){

Merge(arr, i, i + gap - 1, i + 2 * gap - 1);

}

// 余下两个子表，后者长度小于gap

if (i + gap - 1 length) {

Merge(arr, i, i + gap - 1, length - 1);

}

private static void Merge(int[] arr,int low,int mid,int high){

int i=low;// i是第一段序列的下标

int j = mid +1;// j是第二段序列的下标

int k = 0;// k是临时存放合并序列的下标

int[] array2 = new int[high - low + 1]; // array2是临时合并序列

// 扫描第一段和第二段序列，直到有一个扫描结束

while (i = mid j = high) {

// 判断第一段和第二段取出的数哪个更小，将其存入合并序列，并继续向下扫描

if (arr[i] = arr[j]) {

array2[k] = arr[i];

i++;

k++;

} else {

array2[k] = arr[j];

j++;

k++;

}

// 若第一段序列还没扫描完，将其全部复制到合并序列

while(i = mid){

array2[k] = arr[i];

i++;

k++;

}

// 若第二段序列还没扫描完，将其全部复制到合并序列

while(j = high){

array2[k] = arr[j];

j++;

k++;

}

// 将合并序列复制到原始序列中

for (k = 0, i = low; i = high; i++, k++) {

arr[i] = array2[k];

}

运行结果:

排序前: 9 1 5 3 4 2 6 8 7

gap = 1: 1 9 3 5 2 4 6 8 7

gap = 2: 1 3 5 9 2 4 6 8 7

gap = 4: 1 2 3 4 5 6 8 9 7

gap = 8: 1 2 3 4 5 6 7 8 9

排序后: 1 2 3 4 5 6 7 8 9

java归并排序

.example-btn{color:#fff;background-color:#5cb85c;border-color:#4cae4c}.example-btn:hover{color:#fff;background-color:#47a447;border-color:#398439}.example-btn:active{background-image:none}div.example{width:98%;color:#000;background-color:#f6f4f0;background-color:#d0e69c;background-color:#dcecb5;background-color:#e5eecc;margin:0 0 5px 0;padding:5px;border:1px solid #d4d4d4;background-image:-webkit-linear-gradient(#fff,#e5eecc 100px);background-image:linear-gradient(#fff,#e5eecc 100px)}div.example_code{line-height:1.4em;width:98%;background-color:#fff;padding:5px;border:1px solid #d4d4d4;font-size:110%;font-family:Menlo,Monaco,Consolas,"Andale Mono","lucida console","Courier New",monospace;word-break:break-all;word-wrap:break-word}div.example_result{background-color:#fff;padding:4px;border:1px solid #d4d4d4;width:98%}div.code{width:98%;border:1px solid #d4d4d4;background-color:#f6f4f0;color:#444;padding:5px;margin:0}div.code div{font-size:110%}div.code div,div.code p,div.example_code p{font-family:"courier new"}pre{margin:15px auto;font:12px/20px Menlo,Monaco,Consolas,"Andale Mono","lucida console","Courier New",monospace;white-space:pre-wrap;word-break:break-all;word-wrap:break-word;border:1px solid #ddd;border-left-width:4px;padding:10px 15px} 排序算法是《数据结构与算法》中最基本的算法之一。排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。以下是归并排序算法：

归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：

自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；自下而上的迭代；

在《数据结构与算法 JavaScript 描述》中，作者给出了自下而上的迭代方法。但是对于递归法，作者却认为：

However, it is not possible to do so in JavaScript, as the recursion goes too deep for the language to handle.

然而，在 JavaScript 中这种方式不太可行，因为这个算法的递归深度对它来讲太深了。

说实话，我不太理解这句话。意思是 JavaScript 编译器内存太小，递归太深容易造成内存溢出吗？还望有大神能够指教。

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是 O(nlogn) 的时间复杂度。代价是需要额外的内存空间。

2. 算法步骤

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

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

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

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

将另一序列剩下的所有元素直接复制到合并序列尾。

3. 动图演示

代码实现 JavaScript 实例 function mergeSort ( arr ) { // 采用自上而下的递归方法

var len = arr. length ;

if ( len

分享题目：java中归并排序的代码 java归并排序算法
链接分享：http://bzwzjz.com/article/hghdpg.html

用户体验为先导为品牌带来生命力

java中归并排序的代码 java归并排序算法

java 归并排序算法问题

java实现归并排序问题

归并排序的示例代码

JAVA归并排序算法，有两行代码看不懂

归并排序详解

java归并排序

其他资讯

用户体验为先导 为品牌带来生命力

java中归并排序的代码 java归并排序算法

java 归并排序算法问题

java实现归并排序问题

归并排序的示例代码

JAVA归并排序算法，有两行代码看不懂

归并排序详解

java归并排序

其他资讯

用户体验为先导为品牌带来生命力