java---递归的理解到由递归引入动态规划

                                                         

1.     理解递归

2      Fibonacci     递归写法

3.     由暴力递归到动态规划    

递归的过程很复杂，而且递归也很重要，它能够解决我们遇到的很多问题。所以理解递归很重要。

再一个就是在学习算法的时候我们会遇见动态规划，直接解决动态规划对于大多数人来说都不太现实，而从暴力递归到动态规划就相对变得简单一点了。

1.递归的理解

如何用递归实现数字倒着输出？

	public static void Number1(int n) {
		//先要有递归出口
		if(n<=0)
			return ;
		System.out.print(n+" ");
		Number1(n-1);
	}

如何用递归实现连续数字正着输出？

	public static void Number2(int n) {
		//先要有递归出口
		if(n<=0)
			return ;
		Number2(n-1);
		System.out.print(n+" ");
	}

 如何利用递归让一段连续的数字先倒序输出再正着输出一遍？

	public static void Number4(int n) {
		//先要有递归出口
		if(n<=0)
			return ;
		System.out.print(n+" ");
		Number4(n-1);
		System.out.print(n+" ");
	}

接下来一个理解递归的就和二叉树相关了、

	public static void Number3(int n) {
		//先要有递归出口
		if(n<=0)
			return ;
		Number3(n-1);
		System.out.print(n+" ");
		Number3(n-1);
	}

 接下来是Fibonacci的递归写法。

//斐波那契数列递归的写法
	//n代表你想要斐波那契数列的第n项
	public static int Fibo(int n){
		//首先必须要递归的出口，不然就会陷入死循环
		if(n==1||n==2)
			return 1;
		return Fibo(n-1)+Fibo(n-2);
	}

由Fibonacci递归写法改成动态规划

//这里我们先提前引入一下动态规划。
	//我们会发现，在递归的过程中，有很多数被重复运算，有没有一种办法不重复的运算这些数呢？
	//动态规划！使用动态规划，每次生成的数放到一个数组当中，下次要用到的时候直接调用表中
	//的数值即可
	public static int Fibo1(int n) {
		int dp[]=new int[n+2];
		//接下来就是填表
			dp[1]=1;
			dp[2]=1;
			if(n>=3) {
				for(int i=3;i<=n;i++)
					dp[i]=dp[i-1]+dp[i-2];
			}
		return dp[n];
	}

上面这个动态规划我们开辟了一个n长度的数组，我们还可以对空间进行优化，就是开辟一个长度为3的数组即可，重复利用这段空间

	public static int Fibo2(int n) {
		int dp[]=new int[3];
		int k1 = 1;
		//接下来就是填表
			dp[0]=1;
			dp[1]=1;
			if(n>=3) {
				for(int i=3;i<=n;i++) {
					k1=(i+2)%3;
				dp[k1]=dp[(i+1)%3]+dp[i%3];
				}
			}
		return dp[k1];
	}

接下来是总代码

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//体验一下递归的感觉
		Number1(5);
		System.out.println();
		Number2(5);
		System.out.println();
		Number3(5);
		System.out.println();
		Number4(5);
		System.out.println();
		System.out.println("=========================");
		System.out.println("Fibonacci的第10个数是："+Fibo(10));
		System.out.println("打印Fibonacci的前10项");
		for(int i=1;i<=10;i++) {
			System.out.printf("%-5d",Fibo(i));
			if(i%5==0)
				System.out.println();
		}
		System.out.println("=========动态规划===========");
		System.out.println("Fibonacci的第10个数是："+Fibo1(10));
		System.out.println("打印Fibonacci的前10项");
		for(int i=1;i<=10;i++) {
			System.out.printf("%-5d",Fibo1(i));
			if(i%5==0)
				System.out.println();
		}
		System.out.println("==========优化空间后的动态规划==========");
		System.out.println("Fibonacci的第10个数是："+Fibo2(10));
		System.out.println("打印Fibonacci的前10项");
		for(int i=1;i<=10;i++) {
			System.out.printf("%-5d",Fibo2(i));
			if(i%5==0)
				System.out.println();
		}
	}
	//斐波那契数列递归的写法
	//n代表你想要斐波那契数列的第n项
	public static int Fibo(int n){
		//首先必须要递归的出口，不然就会陷入死循环
		if(n==1||n==2)
			return 1;
		return Fibo(n-1)+Fibo(n-2);
	}
	//这里我们先提前引入一下动态规划。
	//我们会发现，在递归的过程中，有很多数被重复运算，有没有一种办法不重复的运算这些数呢？
	//动态规划！使用动态规划，每次生成的数放到一个数组当中，下次要用到的时候直接调用表中
	//的数值即可
	public static int Fibo1(int n) {
		int dp[]=new int[n+2];
		//接下来就是填表
			dp[1]=1;
			dp[2]=1;
			if(n>=3) {
				for(int i=3;i<=n;i++)
					dp[i]=dp[i-1]+dp[i-2];
			}
		return dp[n];
	}
	//还可以进一步的优化空间
	public static int Fibo2(int n) {
		int dp[]=new int[3];
		int k1 = 1;
		//接下来就是填表
			dp[0]=1;
			dp[1]=1;
			if(n>=3) {
				for(int i=3;i<=n;i++) {
					k1=(i+2)%3;
				dp[k1]=dp[(i+1)%3]+dp[i%3];
				}
			}
		return dp[k1];
	}
	public static void Number1(int n) {
		//先要有递归出口
		if(n<=0)
			return ;
		System.out.print(n+" ");
		Number1(n-1);
	}
	public static void Number2(int n) {
		//先要有递归出口
		if(n<=0)
			return ;
		Number2(n-1);
		System.out.print(n+" ");
	}
	public static void Number3(int n) {
		//先要有递归出口
		if(n<=0)
			return ;
		Number3(n-1);
		System.out.print(n+" ");
		Number3(n-1);
	}
	public static void Number4(int n) {
		//先要有递归出口
		if(n<=0)
			return ;
		System.out.print(n+" ");
		Number4(n-1);
		System.out.print(n+" ");
	}

那么有人会问了，既然暴力递归能解决这个问题，那我们为何还要引入动态规划？

因为动态规划能够 节省很多时间。在暴力递归的过程中，有些过程反复计算，这样使我们的程序时间复杂度过高。

下一节详细的讲一下动态规划