只是补个欠账…
注意：
- 树形结构切分到回复，时间复杂度一般为O(nlogn)
- 递归的归并排序，最大时间复杂度=平均时间复杂度=O(nlogn)
- 递归的归并排序是按照深度优先在树上进行的。
伪码描述：
MERGE_SORT(A,p,r)
//p<r时，至少还有两个数字。
//当元素个数为偶数，即p+r为奇数时，(p+r)/2落在中线之前的那个元素。
if p<r then q<--(p+r)/2
//分解过程
MERGE-SORT(A,p,q)
MERGE-SORT(A,q+1,r)
//合并过程
MERGE(A,p,q,r)
MERGR(A,p,q,r)
n1<--q-p+1;n2<--r-q //n1为左半部分元素个数，m2为右半部分元素个数
create arrays L[1..n1] and R[1..n2]
for i<--1 to n1 do L[i]<--A[p+i-1]
for j<--1 to n2 do R[j]<--A[q+j]
i<--1;j<--1
for k<--p to r
do if L[i]<=R[j]
then A[k] == L[i]
i<--i+1
else A[k] == R[j]
j<--j+1
递归实现：
import java.util.Scanner;
public class 归并递归实现 {
static void merge(int a[],int lb,int mid,int ub) {
int n1 = mid-lb+1;
int n2 = ub - mid;
int L[]=new int[n1+1];
int R[]=new int[n2+1];
for(int i=0;i<n1;i++) {
L[i]=a[lb+i];
}
for(int i=0;i<n2;i++) {
R[i]=a[mid+1+i];
}
L[n1]=R[n2]=Integer.MAX_VALUE;
int i=0,j=0;
for (int k=lb;k<=ub;k++) {
if(L[i]<=R[j]) {
a[k]=L[i];
i++;
}else {
a[k]=R[j];
j++;
}
}
}
static void mergeSort(int a[],int lb,int ub) {
if(lb<ub) {
int mid=(lb+ub)/2;
mergeSort(a,lb,mid);
mergeSort(a, mid+1, ub);
merge(a,lb,mid,ub);
}
}
public static void main(String args[]) {
Scanner sc=new Scanner(System.in);
int a[]=new int[100];
int k=sc.nextInt();
for(int i=0;i<k;i++) {
a[i]=sc.nextInt();
}
mergeSort(a, 0, k-1);
for(int i=0;i<k;i++) {
System.out.println(a[i]);
}
}
}