归并排序（递归与非递归写法）

递归版本：

public static void merge(int[] arr, int L, int M ,int R){
		int [] help = new int[R-L+1];
		int p1 = L;
		int p2 = M;
		int i = 0;
		while(p1<=M&&p2<=R){
			help[i++] = arr[p1]>arr[p2]?arr[p2++]:arr[p1++];
		}
		while(p1<=M){
			help[i++] = arr[p1++];
		}
		while(p2<=R){
			help[i++] = arr[p2++];
		}
		
		for (int j = 0; j < help.length; j++) {
			arr[L+j] = help[j]; 
		}
	}
	
	
	public void mergesort(int[] arr) {
		if (arr.length<2||arr==null) { return;}
		process(arr, 0, arr.length-1);
	}
	
	public static void process(int[] arr,int L, int R){
		if (L == R) { return;} //base case
		int mid = L+(R-L)>>1;
		process(arr, L, mid-1);
		process(arr, mid, R);
		merge(arr, L, mid,R);
		
	}

 

 

非递归版本：

public static void mergesort2(int []arr){
		if(arr == null||arr.length<2) return;
		
		int N = arr.length;
		int mergesize = 1;
		
		while(mergesize<N){
			int L = 0;  //计算左侧
			while(L<N){
				int M = L +mergesize-1;
				if(M>=N) break; //左侧不够一组处理  左侧不够一组时，剩余的数已经有序，不用管
				
				int R = Math.min(M+mergesize, N-1); //计算右侧 右侧不够一组处理
				merge(arr,L,M,R);
				L = R+1;
			}
			if (mergesize>N/2) {
				break;				
			}
			mergesize<<=1;
			
		}
	}