锐客网

  1. 首页 > 睿知 > it技术 > >

归并排序Java代码递归 归并排序java实现

排序IT技术

JAVA归并排序算法 ， 有两行代码看不懂以var a = [4,2,6,3,1,9,5,7,8,0];为例子 。
1.希尔排序 。希尔排序是在插入排序上面做归并排序Java代码递归的升级 。是先跟距离较远的进行比较的一些方法 。
function shellsort(arr){var i,k,j,len=arr.length,gap = Math.ceil(len/2),temp;while(gap0){for (var k = 0; kgap; k) {var tagArr = [];tagArr.push(arr[k])for (i = k gap; ilen; i=i gap) {temp = arr[i];tagArr.push(temp);for (j=i-gap; j -1; j=j-gap) {if(arr[j]temp){arr[j gap] = arr[j];}else{break;}}arr[j gap] = temp;}console.log(tagArr,"gap:" gap);//输出当前进行插入排序的数组 。console.log(arr);//输出此轮排序后的数组 。}gap = parseInt(gap/2);}return arr;}
过程输出：
[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：
[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]
间隔为2：
[4, 2, 6, 3, 0, 9, 5, 7, 8, 1]4605823971
排序后：
[0, 1, 4, 2, 5, 3, 6, 7, 8, 9]
间隔为1：
排序后：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 。
2.快速排序 。把一个数组以数组中的某个值为标记 。比这个值小的放到数组的左边归并排序Java代码递归 ， 比这个值得大的放到数组的右边 。然后再递归 对左边和右边的数组进行同样的操作 。直到排序完成 。通常以数组的第一个值为标记 。
代码:
function quickSort(arr){var len = arr.length,leftArr=[],rightArr=[],tag;if(len2){return arr;}tag = arr[0];for(i=1;ilen;i){if(arr[i]=tag){leftArr.push(arr[i])}else{rightArr.push(arr[i]);}}return quickSort(leftArr).concat(tag,quickSort(rightArr));}
3.归并排序 。把一系列排好序的子序列合并成一个大的完整有序序列 。从最小的单位开始合并 。然后再逐步合并合并好的有序数组 。最终实现归并排序 。
合并两个有序数组的方法：
function subSort(arr1,arr2){var len1 = arr1.length,len2 = arr2.length,i=0,j=0,arr3=[],bArr1 = arr1.slice(),bArr2 = arr2.slice();while(bArr1.length!=0 || bArr2.length!=0){if(bArr1.length == 0){arr3 = arr3.concat(bArr2);bArr2.length = 0;}else if(bArr2.length == 0){arr3 = arr3.concat(bArr1);bArr1.length = 0;}else{if(bArr1[0]=bArr2[0]){arr3.push(bArr1[0]);bArr1.shift();}else{arr3.push(bArr2[0]);bArr2.shift();}}}return arr3;}
归并排序：
function mergeSort(arr){var len= arr.length,arrleft=[],arrright =[],gap=1,maxgap=len-1,gapArr=[],glen,n;while(gapmaxgap){gap = Math.pow(2,n);if(gap=maxgap){gapArr.push(gap);}n;}glen = gapArr.length;for (var i = 0; iglen; i) {gap = gapArr[i];for (var j = 0; jlen; j=j gap*2) {arrleft = arr.slice(j, j gap);arrright = arr.slice(j gap,j gap*2);console.log("left:" arrleft,"right:" arrright);arr = arr.slice(0,j).concat(subSort(arrleft,arrright),arr.slice(j gap*2));}}return arr;}
排序[4,2,6,3,1,9,5,7,8,0]输出：
left:4 right:2left:6 right:3left:1 right:9left:5 right:7left:8 right:0left:2,4 right:3,6left:1,9 right:5,7left:0,8 right:left:2,3,4,6 right:1,5,7,9left: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];
java编程的冒泡等排序示例Java排序算法
1）分类：
1）插入排序（直接插入排序、希尔排序）
2）交换排序（冒泡排序、快速排序）
3）选择排序（直接选择排序、堆排序）
4）归并排序
5）分配排序（箱排序、基数排序）
所需辅助空间最多：归并排序
所需辅助空间最少：堆排序
平均速度最快：快速排序
不稳定：快速排序，希尔排序 ， 堆排序 。
1）选择排序算法的时候
1.数据的规模 ；2.数据的类型 ；3.数据已有的顺序
一般来说，当数据规模较小时，应选择直接插入排序或冒泡排序 。任何排序算法在数据量小时基本体现不出来差距 。考虑数据的类型，比如如果全部是正整数，那么考虑使用桶排序为最优 。考虑数据已有顺序，快排是一种不稳定的排序（当然可以改进），对于大部分排好的数据，快排会浪费大量不必要的步骤 。数据量极小 ， 而起已经基本排好序，冒泡是最佳选择 。我们说快排好，是指大量随机数据下 ， 快排效果最理想 。而不是所有情况 。
3）总结：
——按平均的时间性能来分：
1）时间复杂度为O(nlogn)的方法有：快速排序、堆排序和归并排序，其中以快速排序为最好；
2）时间复杂度为O(n2)的有：直接插入排序、起泡排序和简单选择排序，其中以直接插入为最好，特别是对那些对关键字近似有序的记录序列尤为如此；
3）时间复杂度为O(n)的排序方法只有，基数排序 。
当待排记录序列按关键字顺序有序时，直接插入排序和起泡排序能达到O(n)的时间复杂度;而对于快速排序而言，这是最不好的情况 ， 此时的时间性能蜕化为O(n2)，因此是应该尽量避免的情况 。简单选择排序、堆排序和归并排序的时间性能不随记录序列中关键字的分布而改变 。
——按平均的空间性能来分（指的是排序过程中所需的辅助空间大?。?
1） 所有的简单排序方法(包括：直接插入、起泡和简单选择)和堆排序的空间复杂度为O(1)；
2） 快速排序为O(logn )，为栈所需的辅助空间;
3） 归并排序所需辅助空间最多，其空间复杂度为O(n );
4）链式基数排序需附设队列首尾指针，则空间复杂度为O(rd ) 。
——排序方法的稳定性能：
1） 稳定的排序方法指的是，对于两个关键字相等的记录，它们在序列中的相对位置，在排序之前和 经过排序之后，没有改变 。
2） 当对多关键字的记录序列进行LSD方法排序时，必须采用稳定的排序方法 。
3） 对于不稳定的排序方法，只要能举出一个实例说明即可 。
【归并排序Java代码递归 归并排序java实现】 4） 快速排序，希尔排序和堆排序是不稳定的排序方法 。
4）插入排序：
包括直接插入排序，希尔插入排序 。
直接插入排序： 将一个记录插入到已经排序好的有序表中 。
1, sorted数组的第0个位置没有放数据 。
2，从sorted第二个数据开始处理：
如果该数据比它前面的数据要?。得鞲檬菀懊嬉贫?。
首先将该数据备份放到 sorted的第0位置当哨兵 。
然后将该数据前面那个数据后移 。
然后往前搜索，找插入位置 。
找到插入位置之后讲 第0位置的那个数据插入对应位置 。
O(n*n), 当待排记录序列为正序时 ， 时间复杂度提高至O(n) 。
希尔排序（缩小增量排序 diminishing increment sort）：先将整个待排记录序列分割成若干个子序列分别进行直接插入排序，待整个序列中的记录基本有序时，再对全体记录进行一次直接插入排序 。
面试穿什么，这里找答案！
插入排序Java代码：
public class InsertionSort {
// 插入排序：直接插入排序 ，希尔排序
public void straightInsertionSort(double [] sorted){
int sortedLen= sorted.length;
for(int j=2;jsortedLen;j){
if(sorted[j]sorted[j-1]){
sorted[0]= sorted[j];//先保存一下后面的那个
sorted[j]=sorted[j-1];// 前面的那个后移 。
int insertPos=0;
for(int k=j-2;k=0;k--){
if(sorted[k]sorted[0]){
sorted[k 1]=sorted[k];
}else{
insertPos=k 1;
break;
}
}
sorted[insertPos]=sorted[0];
}
}
}
public void shellInertionSort(double [] sorted, int inc){
int sortedLen= sorted.length;
for(int j=inc 1;jsortedLen;j){
if(sorted[j]sorted[j-inc]){
sorted[0]= sorted[j];//先保存一下后面的那个
int insertPos=j;
for(int k=j-inc;k=0;k-=inc){
if(sorted[k]sorted[0]){
sorted[k inc]=sorted[k];
//数据结构课本上这个地方没有给出判读，出错：
if(k-inc=0){
insertPos = k;
}
}else{
insertPos=k inc;
break;
}
}
sorted[insertPos]=sorted[0];
}
}
}
public void shellInsertionSort(double [] sorted){
int[] incs={7,5,3,1};
int num= incs.length;
int inc=0;
for(int j=0;jnum;j){
inc= incs[j];
shellInertionSort(sorted,inc);
}
}
public static void main(String[] args) {
Random random= new Random(6);
int arraysize= 21;
double [] sorted=new double[arraysize];
System.out.print("Before Sort:");
for(int j=1;jarraysize;j){
sorted[j]= (int)(random.nextDouble()* 100);
System.out.print((int)sorted[j] " ");
}
System.out.println();
InsertionSort sorter=new InsertionSort();
//sorter.straightInsertionSort(sorted);
sorter.shellInsertionSort(sorted);
System.out.print("After Sort:");
for(int j=1;jsorted.length;j){
System.out.print((int)sorted[j] " ");
}
System.out.println();
}
}
面试穿什么，这里找答案！
5）交换排序：
包括冒泡排序 ， 快速排序 。
冒泡排序法：该算法是专门针对已部分排序的数据进行排序的一种排序算法 。如果在你的数据清单中只有一两个数据是乱序的话 ， 用这种算法就是最快的排序算法 。如果你的数据清单中的数据是随机排列的，那么这种方法就成了最慢的算法了 。因此在使用这种算法之前一定要慎重 。这种算法的核心思想是扫描数据清单，寻找出现乱序的两个相邻的项目 。当找到这两个项目后，交换项目的位置然后继续扫描 。重复上面的操作直到所有的项目都按顺序排好 。
快速排序：通过一趟排序 ， 将待排序记录分割成独立的两个部分 ， 其中一部分记录的关键字均比另一部分记录的关键字?。?则可分别对这两部分记录继续进行排序，以达到整个序列有序 。具体做法是：使用两个指针low,high, 初值分别设置为序列的头，和序列的尾，设置pivotkey为第一个记录，首先从high开始向前搜索第一个小于pivotkey的记录和pivotkey所在位置进行交换，然后从low开始向后搜索第一个大于pivotkey的记录和此时pivotkey所在位置进行交换，重复知道low=high了为止 。
交换排序Java代码：
public class ExchangeSort {
public void BubbleExchangeSort(double [] sorted){
int sortedLen= sorted.length;
for(int j=sortedLen;j0;j--){
int end= j;
for(int k=1;kend-1;k){
double tempB= sorted[k];
sorted[k]= sorted[k]sorted[k 1]?
sorted[k]:sorted[k 1];
if(Math.abs(sorted[k]-tempB)10e-6){
sorted[k 1]=tempB;
}
}
}
}
public void QuickExchangeSortBackTrack(double [] sorted,
int low,int high){
if(lowhigh){
int pivot= findPivot(sorted,low,high);
QuickExchangeSortBackTrack(sorted,low,pivot-1);
QuickExchangeSortBackTrack(sorted,pivot 1,high);
}
}
public int findPivot(double [] sorted, int low, int high){
sorted[0]= sorted[low];
while(lowhigh){
while(lowhighsorted[high]= sorted[0])--high;
sorted[low]= sorted[high];
while(lowhighsorted[low]=sorted[0])low;
sorted[high]= sorted[low];
}
sorted[low]=sorted[0];
return low;
}
public static void main(String[] args) {
Random random= new Random(6);
int arraysize= 21;
double [] sorted=new double[arraysize];
System.out.print("Before Sort:");
for(int j=1;jarraysize;j){
sorted[j]= (int)(random.nextDouble()* 100);
System.out.print((int)sorted[j] " ");
}
System.out.println();
ExchangeSort sorter=new ExchangeSort();
//sorter.BubbleExchangeSort(sorted);
sorter.QuickExchangeSortBackTrack(sorted, 1, arraysize-1);
System.out.print("After Sort:");
for(int j=1;jsorted.length;j){
System.out.print((int)sorted[j] " ");
}
System.out.println();
}
}
6）选择排序：
分为直接选择排序，堆排序
直接选择排序：第i次选取 i到array.Length-1中间最小的值放在i位置 。
堆排序：首先 ， 数组里面用层次遍历的顺序放一棵完全二叉树 。从最后一个非终端结点往前面调整，直到到达根结点，这个时候除根节点以外的所有非终端节点都已经满足堆得条件了 ， 于是需要调整根节点使得整个树满足堆得条件 ， 于是从根节点开始，沿着它的儿子们往下面走（最大堆沿着最大的儿子走，最小堆沿着最小的儿子走） 。主程序里面，首先从最后一个非终端节点开始调整到根也调整完，形成一个heap，然后将heap的根放到后面去（即：每次的树大小会变化 ， 但是 root都是在1的位置，以方便计算儿子们的index，所以如果需要升序排列 ， 则要逐步大顶堆 。因为根节点被一个个放在后面去了 。降序排列则要建立小顶堆）
代码中的问题： 有时候第2个和第3个顺序不对（原因还没搞明白到底代码哪里有错）
选择排序Java代码：
public class SelectionSort {
public void straitSelectionSort(double [] sorted){
int sortedLen= sorted.length;
for(int j=1;jsortedLen;j){
int jMin= getMinIndex(sorted,j);
exchange(sorted,j,jMin);
}
}
public void exchange(double [] sorted,int i,int j){
int sortedLen= sorted.length;
if(isortedLenjsortedLeniji=0j=0){
double temp= sorted[i];
sorted[i]=sorted[j];
sorted[j]=temp;
}
}
public int getMinIndex(double [] sorted, int i){
int sortedLen= sorted.length;
int minJ=1;
double min= Double.MAX_VALUE;
for(int j=i;jsortedLen;j){
if(sorted[j]min){
min= sorted[j];
minJ= j;
}
}
return minJ;
}
public void heapAdjust(double [] sorted,int start,int end){
if(startend){
double temp= sorted;
//这个地方jend与课本不同，j=end会报错：
for(int j=2*start;jend;j *=2){
if(j 1endsorted[j]-sorted[j 1]10e-6){
j;
}
if(temp=sorted[j]){
break;
}
sorted=sorted[j];
start=j;
}
sorted=temp;
}
}
public void heapSelectionSort(double [] sorted){
int sortedLen = sorted.length;
for(int i=sortedLen/2;i0;i--){
heapAdjust(sorted,i,sortedLen);
}
for(int i=sortedLen;i1;--i){
exchange(sorted,1,i);
heapAdjust(sorted,1,i-1);
}
}
public static void main(String [] args){
Random random= new Random(6);
int arraysize=9;
double [] sorted=new double[arraysize];
System.out.print("Before Sort:");
for(int j=1;jarraysize;j){
sorted[j]= (int)(random.nextDouble()* 100);
System.out.print((int)sorted[j] " ");
}
System.out.println();
SelectionSort sorter=new SelectionSort();
//sorter.straitSelectionSort(sorted);
sorter.heapSelectionSort(sorted);
System.out.print("After Sort:");
for(int j=1;jsorted.length;j){
System.out.print((int)sorted[j] " ");
}
System.out.println();
}
}
面试穿什么 ， 这里找答案！
7）归并排序：
将两个或两个以上的有序表组合成一个新的有序表 。归并排序要使用一个辅助数组，大小跟原数组相同，递归做法 。每次将目标序列分解成两个序列，分别排序两个子序列之后 ， 再将两个排序好的子序列merge到一起 。
归并排序Java代码：
public class MergeSort {
private double[] bridge;//辅助数组
public void sort(double[] obj){
if (obj == null){
throw new NullPointerException("
The param can not be null!");
}
bridge = new double[obj.length]; // 初始化中间数组
mergeSort(obj, 0, obj.length - 1); // 归并排序
bridge = null;
}
private void mergeSort(double[] obj, int left, int right){
if (leftright){
int center = (leftright) / 2;
mergeSort(obj, left, center);
mergeSort(obj, center1, right);
merge(obj, left, center, right);
}
}
private void merge(double[] obj, int left,
int center, int right){
int mid = center1;
int third = left;
int tmp = left;
while (left = centermid = right){
// 从两个数组中取出小的放入中间数组
if (obj[left]-obj[mid]=10e-6){
bridge[third] = obj[left];
} else{
bridge[third] = obj[mid];
}
}
// 剩余部分依次置入中间数组
while (mid = right){
bridge[third] = obj[mid];
}
while (left = center){
bridge[third] = obj[left];
}
// 将中间数组的内容拷贝回原数组
copy(obj, tmp, right);
}
private void copy(double[] obj, int left, int right)
{
while (left = right){
obj[left] = bridge[left];
left;
}
}
public static void main(String[] args) {
Random random = new Random(6);
int arraysize = 10;
double[] sorted = new double[arraysize];
System.out.print("Before Sort:");
for (int j = 0; jarraysize; j) {
sorted[j] = (int) (random.nextDouble() * 100);
System.out.print((int) sorted[j]" ");
}
System.out.println();
MergeSort sorter = new MergeSort();
sorter.sort(sorted);
System.out.print("After Sort:");
for (int j = 0; jsorted.length; j) {
System.out.print((int) sorted[j]" ");
}
System.out.println();
}
}
面试穿什么 ， 这里找答案！
8）基数排序：
使用10个辅助队列，假设最大数的数字位数为 x， 则一共做 x次 ， 从个位数开始往前，以第i位数字的大小为依据，将数据放进辅助队列，搞定之后回收 。下次再以高一位开始的数字位为依据 。
以Vector作辅助队列 ， 基数排序的Java代码：
public class RadixSort {
private int keyNum=-1;
private VectorVectorDouble util;
public void distribute(double [] sorted, int nth){
if(nth=keyNumnth0){
util=new VectorVectorDouble();
for(int j=0;j10;j){
Vector Double temp= new Vector Double();
util.add(temp);
}
for(int j=0;jsorted.length;j){
int index= getNthDigit(sorted[j],nth);
util.get(index).add(sorted[j]);
}
}
}
public int getNthDigit(double num,int nth){
String nn= Integer.toString((int)num);
int len= nn.length();
if(len=nth){
return Character.getNumericValue(nn.charAt(len-nth));
}else{
return 0;
}
}
public void collect(double [] sorted){
int k=0;
for(int j=0;j10;j){
int len= util.get(j).size();
if(len0){
for(int i=0;ilen;i){
sorted[k]= util.get(j).get(i);
}
}
}
util=null;
}
public int getKeyNum(double [] sorted){
double max= Double.MIN_VALUE;
for(int j=0;jsorted.length;j){
if(sorted[j]max){
max= sorted[j];
}
}
return Integer.toString((int)max).length();
}
public void radixSort(double [] sorted){
if(keyNum==-1){
keyNum= getKeyNum(sorted);
}
for(int i=1;i=keyNum;i){
distribute(sorted,i);
collect(sorted);
}
}
public static void main(String[] args) {
Random random = new Random(6);
int arraysize = 21;
double[] sorted = new double[arraysize];
System.out.print("Before Sort:");
for (int j = 0; jarraysize; j) {
sorted[j] = (int) (random.nextDouble() * 100);
System.out.print((int) sorted[j]" ");
}
System.out.println();
RadixSort sorter = new RadixSort();
sorter.radixSort(sorted);
System.out.print("After Sort:");
for (int j = 0; jsorted.length; j) {
System.out.print((int) sorted[j]" ");
}
System.out.println();
}
}
//copy而来
java编程题,对一组{23,55,-65,89,82,99,128}中的元素从小到大进行排序1. 插入排序：插入排序基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据 ， 算法适用于少量数据的排序，时间复杂度为O(n^2) 。是稳定的排序方法 。插入排序的基本思想是：每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止 。
2. 选择排序：选择排序（Selection sort）是一种简单直观的排序算法 。它的工作原理是每一次从待排序的数据元素中选出最?。ɑ蜃畲螅┑囊桓鲈?nbsp;， 存放在序列的起始位置，直到全部待排序的数据元素排完 。选择排序是不稳定的排序方法 。
3. 冒泡排序：冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法 。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来 。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成 。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端 。
4. 快速排序：快速排序（Quicksort）是对冒泡排序的一种改进 。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列 。
5. 归并排序：归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用 。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序 ， 再使子序列段间有序 。若将两个有序表合并成一个有序表 ， 称为二路归并 。
6. 希尔排序：希尔排序(Shell Sort)是插入排序的一种 。也称缩小增量排序 ， 是直接插入排序算法的一种更高效的改进版本 。希尔排序是非稳定排序算法 。希尔排序是把记录按下标的一定增量分组 ， 对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止 。
你看这个链接，网页链接
希望可以帮到你，望采纳~
归并排序的示例代码归并排序原理
归并排序具体工作原理如下（假设序列共有n个元素）归并排序Java代码递归：
将序列每相邻两个数字进行归并操作（merge)归并排序Java代码递归，形成floor(n/2)个序列归并排序Java代码递归，排序后每个序列包含两个元素
将上述序列再次归并，形成floor(n/4)个序列，每个序列包含四个元素
重复步骤2 ， 直到所有元素排序完毕
示例代码
Go语言func mergeSort(r []int) []int {length := len(r)if length = 1 {return r}num := length / 2left := mergeSort(r[:num])right := mergeSort(r[num:])return merge(left, right)}func merge(left, right []int) (result []int) {l, r := 0, 0for llen(left)rlen(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*　第一个有序表归并排序Java代码递归的起始下标*　@param　m*　第二个有序表归并排序Java代码递归的起始下标*　@param　t*　第二个有序表的结束小标**/private　static　void　merge(int[]　a,　int　s,　int　m,　int　t)　{int[]　tmp　=　new　int[t　-　s1];int　i　=　s,　j　=　m,　k　=　0;while　(imj　=　t)　{if　(a[i]　=　a[j])　{tmp[k]　=　a[i];k;i;}　else　{tmp[k]　=　a[j];j;k;}}while　(im)　{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　/　(len1);int　c　=　size((len1)　-　1);//　-------归并到只剩一个有序集合的时候结束算法-------//if　(mid　==　0)return;//　------进行一趟归并排序-------//for　(int　i　=　0;　imid;i)　{s　=　i　*　2　*　len;merge(a,　s,　slen,　(len1)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;　ia.length;i)　{System.out.print(a[i]);}}}Python语言def MergeSort(lists):if len(lists) = 1:return listsnum = int( len(lists)/2 )left = MergeSort(lists[:num])right = MergeSort(lists[num:])return Merge(left, right)def Merge(left,right):r, l=0, 0result=[]while llen(left) and rlen(right):if left[l]right[r]:result.append(left[l])l= 1else:result.append(right[r])r= 1result= 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 1j!=endIndex 1){if(sourceArr[i] = sourceArr[j])tempArr[k] = sourceArr[j];elsetempArr[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(startIndexendIndex){midIndex = (startIndexendIndex) / 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 = qr, 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.length0right.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-1j=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(tempij, dataai, (length - i) * sizeof(int));　}else if(i == length){memcpy(tempij, databj, (right - j)*sizeof(int));}　memcpy(data a, temp, (rightlength) * sizeof(int));　delete [] temp;}void　MergeSort(int*　data, int　n){　int　step = 1;　while(stepn){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 = https://www.04ip.com/post/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排序程序//排序
public class Array
{
public static int[] random(int n)//产生n个随机数 ， 返回整型数组
{
if (n0)
{
int table[] = new int[n];
for (int i=0; itable.length; i)
table[i] = (int)(Math.random()*100);//产生一个0～100之间的随机数
return table;//返回一个数组
}
return null;
}
public static void print(int[] table)//输出数组元素
{
if (table!=null)
for (int i=0; itable.length; i)
System.out.print(" " table[i]);
System.out.println();
}
public static void insertSort(int[] table)//直接插入排序
{//数组是引用类型，元素值将被改变
System.out.println("直接插入排序");
for (int i=1; itable.length; i)//n-1趟扫描
{
int temp=table[i], j;//每趟将table[i]插入到前面已排序的序列中
//System.out.print("移动");
for (j=i-1; j-1temptable[j]; j--)//将前面较大元素向后移动
{
//System.out.print(table[j] ", ");
table[j 1] = table[j];
}
table[j 1] = temp;//temp值到达插入位置
System.out.print("第" i "趟: ");
print(table);
}
}
public static void shellSort(int[] table)//希尔排序
{
System.out.println("希尔排序");
for (int delta=table.length/2; delta0; delta/=2)//控制增量，增量减半，若干趟扫描
{
for (int i=delta; itable.length; i)//一趟中若干组，每个元素在自己所属组内进行直接插入排序
{
int temp = table[i];//当前待插入元素
int j=i-delta;//相距delta远
while (j=0temptable[j])//一组中前面较大的元素向后移动
{
table[j delta] = table[j];
j-=delta;//继续与前面的元素比较
}
table[j delta] = temp;//插入元素位置
}
System.out.print("delta=" delta "");
print(table);
}
}
private static void swap(int[] table, int i, int j)//交换数组中下标为i、j的元素
{
if (i=0itable.lengthj=0jtable.lengthi!=j)//判断i、j是否越界
{
int temp = table[j];
table[j] = table[i];
table[i] = temp;
}
}
public static void bubbleSort(int[] table)//冒泡排序
{
System.out.println("冒泡排序");
boolean exchange=true;//是否交换的标记
for (int i=1; itable.lengthexchange; i)//有交换时再进行下一趟，最多n-1趟
{
exchange=false;//假定元素未交换
for (int j=0; jtable.length-i; j)//一次比较、交换
if (table[j]table[j 1])//反序时，交换
{
int temp = table[j];
table[j] = table[j 1];
table[j 1] = temp;
exchange=true;//有交换
}
System.out.print("第" i "趟: ");
print(table);
}
}
public static void quickSort(int[] table)//快速排序
{
quickSort(table, 0, table.length-1);
}
private static void quickSort(int[] table, int low, int high) //一趟快速排序 ， 递归算法
{//low、high指定序列的下界和上界
if (lowhigh)//序列有效
{
int i=low, j=high;
int vot=table[i];//第一个值作为基准值
while (i!=j)//一趟排序
{
while (ijvot=table[j])//从后向前寻找较小值
j--;
if (ij)
{
table[i]=table[j];//较小元素向前移动
i;
}
while (ijtable[i]vot)//从前向后寻找较大值
i;
if (ij)
{
table[j]=table[i];//较大元素向后移动
j--;
}
}
table[i]=vot;//基准值的最终位置
System.out.print(low ".." high ",vot=" vot "");
print(table);
quickSort(table, low, j-1);//前端子序列再排序
quickSort(table, i 1, high);//后端子序列再排序
}
}
public static void selectSort(int[] table)//直接选择排序
{
System.out.println("直接选择排序");
for (int i=0; itable.length-1; i)//n-1趟排序
{//每趟在从table[i]开始的子序列中寻找最小元素
int min=i;//设第i个数据元素最小
for (int j=i 1; jtable.length; j)//在子序列中查找最小值
if (table[j]table[min])
min = j;//记住最小元素下标
if (min!=i)//将本趟最小元素交换到前边
{
int temp = table[i];
table[i] = table[min];
table[min] = temp;
}
System.out.print("第" i "趟: ");
print(table);
}
}
private static void sift(int[] table, int low, int high) //将以low为根的子树调整成最小堆
{//low、high是序列下界和上界
int i=low;//子树的根
int j=2*i 1;//j为i结点的左孩子
int temp=table[i];//获得第i个元素的值
while (j=high)//沿较小值孩子结点向下筛选
{
if (jhightable[j]table[j 1])//数组元素比较（改成为最大堆）
j;//j为左右孩子的较小者
if (temptable[j])//若父母结点值较大（改成为最大堆）
{
table[i]=table[j];//孩子结点中的较小值上移
i=j;//i、j向下一层
j=2*i 1;
}
else
j=high 1;//退出循环
}
table[i]=temp;//当前子树的原根值调整后的位置
System.out.print("sift" low ".." high "");
print(table);
}
public static void heapSort(int[] table)
{
System.out.println("堆排序");
int n=table.length;
for (int j=n/2-1; j=0; j--)//创建最小堆
sift(table, j, n-1);
//System.out.println("最小堆？ " isMinHeap(table));
for (int j=n-1; j0; j--)//每趟将最小值交换到后面 ， 再调整成堆
{
int temp = table[0];
table[0] = table[j];
table[j] = temp;
sift(table, 0, j-1);
}
}
public static void mergeSort(int[] X)//归并排序
{
System.out.println("归并排序");
int n=1;//已排序的子序列长度，初值为1
int[] Y = new int[X.length];//Y数组长度同X数组
do
{
mergepass(X, Y, n);//一趟归并，将X数组中各子序列归并到Y中
print(Y);
n*=2;//子序列长度加倍
if (nX.length)
{
mergepass(Y, X, n);//将Y数组中各子序列再归并到X中
print(X);
n*=2;
}
} while (nX.length);
}
private static void mergepass(int[] X, int[] Y, int n) //一趟归并
{
System.out.print("子序列长度n=" n "");
int i=0;
while (iX.length-2*n 1)
{
merge(X,Y,i,i n,n);
i= 2*n;
}
if (i nX.length)
merge(X,Y,i,i n,n);//再一次归并
else
for (int j=i; jX.length; j)//将X剩余元素复制到Y中
Y[j]=X[j];
}
private static void merge(int[] X, int[] Y, int m, int r, int n)//一次归并
{
int i=m, j=r, k=m;
while (irjr njX.length)//将X中两个相邻子序列归并到Y中
if (X[i]X[j])//较小值复制到Y中
Y[k]=X[i];
else
Y[k]=X[j];
while (ir)//将前一个子序列剩余元素复制到Y中
Y[k]=X[i];
while (jr njX.length)//将后一个子序列剩余元素复制到Y中
Y[k]=X[j];
}
public static void main(String[] args)
{
//int[] table = {52,26,97,19,66,8,49};//Array.random(9);{49,65,13,81,76,97,38,49};////{85,12,36,24,47,30,53,91,76};//;//{4,5,8,1,2,7,3,6};// {32,26,87,72,26,17};//
int[] table = {13,27,38,49,97,76,49,81};//最小堆
System.out.print("关键字序列: ");
Array.print(table);
//Array.insertSort(table);
//Array.shellSort(table);
//Array.bubbleSort(table);
//Array.quickSort(table);
//Array.selectSort(table);
//Array.heapSort(table);
//Array.mergeSort(table);
System.out.println("最小堆序列? " Array.isMinHeap(table));
}
//第9章习题
public static boolean isMinHeap(int[] table)//判断一个数据序列是否为最小堆
{
if (table==null)
return false;
int i = table.length/2 -1;//最深一棵子树的根结点
while (i=0)
{
int j=2*i 1;//左孩子
if (jtable.length)
if (table[i]table[j])
return false;
else
if (j 1table.lengthtable[i]table[j 1])//右孩子
return false;
i--;
}
return true;
}
}
/*
程序运行结果如下：
关键字序列:32 26 87 72 26 17 8 40
直接插入排序
第1趟排序:26 32 87 72 26 17 8 40
第2趟排序:26 32 87 72 26 17 8 40
第3趟排序:26 32 72 87 26 17 8 40
第4趟排序:26 26 32 72 87 17 8 40//排序算法稳定
第5趟排序:17 26 26 32 72 87 8 40
第6趟排序:8 17 26 26 32 72 87 40
第7趟排序:8 17 26 26 32 40 72 87
关键字序列:42 1 74 25 45 29 87 53
直接插入排序
第1趟排序:1 42 74 25 45 29 87 53
第2趟排序:1 42 74 25 45 29 87 53
第3趟排序:1 25 42 74 45 29 87 53
第4趟排序:1 25 42 45 74 29 87 53
第5趟排序:1 25 29 42 45 74 87 53
第6趟排序:1 25 29 42 45 74 87 53
第7趟排序:1 25 29 42 45 53 74 87
关键字序列:21 12 2 40 99 97 68 57
直接插入排序
第1趟排序:12 21 2 40 99 97 68 57
第2趟排序:2 12 21 40 99 97 68 57
第3趟排序:2 12 21 40 99 97 68 57
第4趟排序:2 12 21 40 99 97 68 57
第5趟排序:2 12 21 40 97 99 68 57
第6趟排序:2 12 21 40 68 97 99 57
第7趟排序:2 12 21 40 57 68 97 99
关键字序列:27 38 65 97 76 13 27 49 55 4
希尔排序
delta=513 27 49 55 4 27 38 65 97 76
delta=24 27 13 27 38 55 49 65 97 76
delta=14 13 27 27 38 49 55 65 76 97
关键字序列:49 38 65 97 76 13 27 49 55 4//严书
希尔排序
delta=513 27 49 55 4 49 38 65 97 76
delta=24 27 13 49 38 55 49 65 97 76//与严书不同
delta=14 13 27 38 49 49 55 65 76 97
关键字序列:65 34 25 87 12 38 56 46 14 77 92 23
希尔排序
delta=656 34 14 77 12 23 65 46 25 87 92 38
delta=356 12 14 65 34 23 77 46 25 87 92 38
delta=112 14 23 25 34 38 46 56 65 77 87 92
关键字序列:84 12 43 62 86 7 90 91
希尔排序
delta=484 7 43 62 86 12 90 91
delta=243 7 84 12 86 62 90 91
delta=17 12 43 62 84 86 90 91
关键字序列:32 26 87 72 26 17
冒泡排序
第1趟排序:26 32 72 26 17 87
第2趟排序:26 32 26 17 72 87
第3趟排序:26 26 17 32 72 87
第4趟排序:26 17 26 32 72 87
第5趟排序:17 26 26 32 72 87
关键字序列:1 2 3 4 5 6 7 8
冒泡排序
第1趟排序:1 2 3 4 5 6 7 8
关键字序列:1 3 2 4 5 8 6 7
冒泡排序
第1趟排序:1 2 3 4 5 6 7 8
第2趟排序:1 2 3 4 5 6 7 8
关键字序列:4 5 8 1 2 7 3 6
冒泡排序
第1趟排序:4 5 1 2 7 3 6 8
第2趟排序:4 1 2 5 3 6 7 8
第3趟排序:1 2 4 3 5 6 7 8
第4趟排序:1 2 3 4 5 6 7 8
第5趟排序:1 2 3 4 5 6 7 8
关键字序列:38 26 97 19 66 1 5 49
0..7,vot=385 26 1 19 38 66 97 49
0..3,vot=51 5 26 19 38 66 97 49
2..3,vot=261 5 19 26 38 66 97 49
5..7,vot=661 5 19 26 38 49 66 97
关键字序列:38 5 49 26 19 97 1 66
0..7,vot=381 5 19 26 38 97 49 66
0..3,vot=11 5 19 26 38 97 49 66
1..3,vot=51 5 19 26 38 97 49 66
2..3,vot=191 5 19 26 38 97 49 66
5..7,vot=971 5 19 26 38 66 49 97
5..6,vot=661 5 19 26 38 49 66 97
关键字序列:49 38 65 97 76 13 27 49
0..7,vot=4949 38 27 13 49 76 97 65
0..3,vot=4913 38 27 49 49 76 97 65
0..2,vot=1313 38 27 49 49 76 97 65
1..2,vot=3813 27 38 49 49 76 97 65
5..7,vot=7613 27 38 49 49 65 76 97
关键字序列:27 38 65 97 76 13 27 49 55 4
low=0high=9vot=274 27 13 27 76 97 65 49 55 38
low=0high=2vot=44 27 13 27 76 97 65 49 55 38
low=1high=2vot=274 13 27 27 76 97 65 49 55 38
low=4high=9vot=764 13 27 27 38 55 65 49 76 97
low=4high=7vot=384 13 27 27 38 55 65 49 76 97
low=5high=7vot=554 13 27 27 38 49 55 65 76 97
关键字序列:38 26 97 19 66 1 5 49
直接选择排序
第0趟排序:1 26 97 19 66 38 5 49
第1趟排序:1 5 97 19 66 38 26 49
第2趟排序:1 5 19 97 66 38 26 49
第3趟排序:1 5 19 26 66 38 97 49
第4趟排序:1 5 19 26 38 66 97 49
第5趟排序:1 5 19 26 38 49 97 66
第6趟排序:1 5 19 26 38 49 66 97
最小堆
关键字序列:81 49 76 27 97 38 49 13 65
sift3..881 49 76 13 97 38 49 27 65
sift2..881 49 38 13 97 76 49 27 65
sift1..881 13 38 27 97 76 49 49 65
sift0..813 27 38 49 97 76 49 81 65
13 27 38 49 97 76 49 81 65
sift0..727 49 38 65 97 76 49 81 13
sift0..638 49 49 65 97 76 81 27 13
sift0..549 65 49 81 97 76 38 27 13
sift0..449 65 76 81 97 49 38 27 13
sift0..365 81 76 97 49 49 38 27 13
sift0..276 81 97 65 49 49 38 27 13
sift0..181 97 76 65 49 49 38 27 13
sift0..097 81 76 65 49 49 38 27 13
最大堆
关键字序列:49 65 13 81 76 27 97 38 49
sift3..849 65 13 81 76 27 97 38 49
sift2..849 65 97 81 76 27 13 38 49
sift1..849 81 97 65 76 27 13 38 49
sift0..897 81 49 65 76 27 13 38 49
97 81 49 65 76 27 13 38 49
sift0..781 76 49 65 49 27 13 38 97
sift0..676 65 49 38 49 27 13 81 97
sift0..565 49 49 38 13 27 76 81 97
sift0..449 38 49 27 13 65 76 81 97
sift0..349 38 13 27 49 65 76 81 97
sift0..238 27 13 49 49 65 76 81 97
sift0..127 13 38 49 49 65 76 81 97
sift0..013 27 38 49 49 65 76 81 97
关键字序列:52 26 97 19 66 8 49
归并排序
子序列长度n=126 52 19 97 8 66 49
子序列长度n=219 26 52 97 8 49 66
子序列长度n=48 19 26 49 52 66 97
关键字序列:13 27 38 49 97 76 49 81 65
最小堆序列? true
*/
归并排序Java代码递归的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于归并排序java实现、归并排序Java代码递归的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：广州市各区公众号关注排名，广州公众服务平台

    下一篇：如何解决腾讯会员无法连接服务器的问题？ 腾讯会员没有服务器怎么办