归并排序(递归实现)

只是补个欠账…

注意：

• 树形结构切分到回复，时间复杂度一般为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]);
		}
	}
}