使用递归实现归并排序及归并排序的时间复杂度

1.什么是递归：方法调用其本身。

2.怎么样去实现

        需要写递归表达式，递归表达式分为：

                        1）递归出口

                        2）递归关系

例1：斐波那契数：1,1,2,3,5,8,13........n,求第n 项

1)递归关系：f(1)=1,

                       f(2)=1,

                       f(3)=2,

                        f(4)=f(2)+f(3)=3,

                        f(5)=f(3)+f(4)=5,........

                      得出递归关系：  f(n)=f(n-1)+f(n-2)，

2）递归出口就是n=1时f(1)=1,n=2是f(2)=1,是它两个就return

看如下代码：

public class Fiboncii {
	public static void main(String[] args) {
		int a=f(6);
		System.out.println(a);
	}

	private static int f(int i) {
		if(i==1||i==2) {
			return 1;
		}
		
		
		return f(i-1)+f(i-2);
		
	}
}

结果：

因为递归是它自己调用自己本身，浪费资源大，运行时间比循环时间长，所以效率非常的低。 

我们再看用递归的方法实现归并排序：

这是我们要排序的数组：5,7,4,2,0,3,1,6

整体思路如下图：

把它们从中间分开，然后在合并，合并时按分开时的原路合并，并且安大小排序。

先找出递归表达式：

1）递归关系：

                f(arr,left,right)

2)递归出口：left==right时，递归结束再开始合并 

代码如下：

public class Mersort {
	public static void main(String[] args) {
		int[] arr= {1,22,32,12,65,33,98,12};
		mergesort(arr,0,arr.length-1);
		System.out.println(Arrays.toString(arr));
	}
    //递归分解
	private static void mergesort(int[] arr, int left, int right) {
		// TODO Auto-generated method stub
		if(left==right) {
			return;
		}
		int mid=(left+right)/2;
		mergesort(arr, left, mid);
		mergesort(arr, mid+1, right);
		merge(arr,left,mid,right);
	}
    //合并并排序
	private static void merge(int[] arr, int left, int mid,int right) {
		// TODO Auto-generated method stub
		int s1=left;
		int s2=mid+1;
		int[] temp=new int[(right-left)+1];
		int i=0;
		while(s1<=mid&&s2<=right) {
			if(arr[s1]>=arr[s2]) {
				temp[i++]=arr[s2++];
			}else {
				temp[i++]=arr[s1++];
			}
		}
		while(s1<=mid) {
			temp[i++]=arr[s1++];
		}
		while(s2<=right) {
			temp[i++]=arr[s2++];
		}
		for(int j=0;j<temp.length;j++) {
			arr[j+left]=temp[j];
		}
	}
}

由上面执行图可以看到，先递归，再排序，后合并，递归的时间复杂度为log n,排序时间复杂度为n,所以归并的时间复杂度为O（nlogn）