递归的基础运用和讲解

递归设计的规律：
1、找重复（子问题）
2、找重复中的变化量（参数）
3、找参数变化趋势，设计出口，即找边界。一般放在函数的开始（条件判断）。

以下问题只是为了递归练习，有些问题可能用循环解决更方便。
简单递归问题的实现：

一、用递归求阶乘

找重复：求n的阶乘就是求n*(n-1)! ，（n-1）的阶乘就是问题的重复（子问题）
找变化：变化量就是不断减小的n, 应该作为参数。
找边界：每一个递归都得有边界，防止进入死循环。本题的边界在n=1的时候，因为n是不能小于1的。
代码如下：

public static int f1(int n){
		if(n==1) return 1;
		return n*f1(n-1);
	}

二、打印i到j

找重复：打印数字就是本题的重复。
找变化：每次打印的数字是变化的，不断加1.
找边界：i的值不能超过j
代码如下：

public static void f2(int i, int j){
		if(i>j) return;
		System.out.print(i+" ");
		f2(i+1,j);
	}

三、数组求和

找重复：每次加一个数组元素，不断的做加法。
找变化：没次相加的元素是变化的，将数组下标设为参数。
找边界：数组的长度。
代码如下：

public static int f3(int i, int[] arr){
		if(i>=arr.length) return 0;
		return arr[i] + f3(i+1, arr);
	}

四、翻转字符串

找重复：翻转后的结果就是第n个字符（字符串长为n）加上前面（n-1）个字符的翻转。
找变化：子问题的规模变得越来越小，即要翻转的字符串变短。
找边界：当n等于1为出口。

public static String f4(String str, int i){
		//第二个参数为字符串的长度减一，因为从0开始算。
		if(i==0) return String.valueOf(str.charAt(i));
		return str.charAt(i)+f4(str, i-1);
	}

五、斐波那契数列

斐波那契数列：从第三项起每一项都等于前两项的和，第一项和第二项都为1. 求第N项的值。
这题有点特殊，上面四题都是将问题分解为：直接量+小规模子问题
本题的分解为：多个小规模子问题（本题为两个），即（n-1）项加上(n-2)项。
找重复：每一项都等于前两项的和。
找变化：N的值不断减小。
找出口：第一项和第二项就是出口，因为第一项和第二项的值是已知的。
代码如下：

public static int f5(int n){
		if(n==1||n==2) return 1;
		return f5(n-1)+f5(n-2);
	}

六、用辗转相除法求最大公约数

关于辗转相除法可以看另一篇博客：
辗转相除法的说明

找重复：重复地求余，即否f（m, n%m)。
找变化：变化在于参数。
找边界：当第二个参数为0时。

代码如下：

public static int f6(int n, int m){
		if(m==0) return n;
		return f6(m, n%m);
	}

七、将数组的插入排序改递归

递归分解：将数组的排序分解为：将数组的第0个元素到倒数第二个元素进
排序，然后将最后一个插入前面的已完成的排序中。

找重复：不断地进行部分的排序：f（arr, k) = f(arr, k-1) + 将最后一个插入前面已完成的排序。
找变化：k是变化的。
找边界：当K=0时，也就是到数组的第一个元素时是不用进行排序的。

代码如下：

	public static void f7(int[] arr, int k){
		if(k==0) return;
		f7(arr, k-1);
		int m = arr[k];
		int index = k-1;
		while(m<arr[index]){
			arr[index+1] = arr[index];
			index--;
			if(index<0)break;
		}
		arr[index+1] = m;
	}

八、用递归实现二分查找

代码如下：

public static int f8(int[] arr, int n, int min, int max){
		if(min > max){
			System.out.println("没有这个数");
			return -1;
		}
		int mid = (min +max)/2;
		if(n==arr[mid]) return mid;
		if(n>arr[mid]) min = mid +1;
		if(n<arr[mid]) max = mid - 1;
		return f8(arr, n, min, max);
	}

九、小白上楼梯

问题描述：小白正在上楼梯，楼梯有n阶台阶，小白一次可以上一阶、两阶或者三阶，实现一个方法，计算小白有多少种走完楼梯的方式。

解题思路：这题和斐波那契数列很像。当小白在第K个阶梯时剩下的走法就可以分解为当前走一步，当前走两步，当前走三步的所有可能性之和。即f(k) = f(k-1) + f(k-2) + f(k-3)。
找重复：f(n) = f(n-1) + f(n-2) + f(n-3)
找变化：n不断减小，将n设置为参数
找边界：当n=1,也就是只剩下一个阶梯时，就只有一种走法。当n=2, 只有两种走法（一步走完或者分两次走完），当n=3时，有四种走法（一步走完，分三步走完，先走两步再走一步，先走一步再走两步）。

代码如下：

import java.util.*;

public class 小白上楼梯 {
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		int result = 0;
		result = f(n);
		System.out.print(result);
	}
	public static int f(int n){
		if(n==1) return 1;
		if(n==2) return 2;
		if(n==3) return 4;
		return f(n-1) + f(n-2) + f(n-3);
	}
}

总结：递归的关键就在于找重复的部分，也就是将一个问题分解为多步执行的子问题。从数学上说就是找到一个递推公式，并且找到参数的取值范围，即找到边界，递归的出口。

关于一些递归算法时间复杂度如下图：

更多递归题型请看：
机器人走方格问题

硬币凑数问题

括号组合问题

递归常常用于分治思想，有兴趣的可以这篇文章：
递归实现分治思想的应用