递归初步认识例题

肥婆纳妾数列：0，1，1，2，3，5，8，13，21，34，55，89，144……依次类推下去，你会发现，它后一个数等于前面两个数的和。在这个数列中的数字，就被称为斐波那契数。

递归思想：一个数等于前两个数的和。(这并不是废话，这是执行思路)

具体代码：

public static int f(int n){//递归
		if(n==1){
			return 0;
		}else if(n==2){
			return 1;
		}else if(n<1){
			return -1;
		}
		return f(n-1)+f(n-2);
	}
	public static int g(int n){//迭代
		int first=0;
		int second=1;
		int number=0;
		if(n==1){
			return first;
		}else if(n==2){
			return second;
		}
		while(n>2){
			number=first+second;
			n--;
			first=second;
			second=number;
		}
		return number;
	}

阶乘：

递归思想：n! = n * (n-1)! (直接看公式吧)

具体代码：

public class Mains{
	public static void main(String[] args) {
		for (int i = 0; i < 11; i++) {
			System.out.print("i="+i+",值="+f(i)+" ");
		}
		System.out.println();
		for (int i = 0; i < 11; i++) {
			System.out.print("i="+i+",值="+g(i)+" ");
		}
	}
	public static int f(int n){//递归
		if(n==0){return 1;}
		return n*f(n-1);
	}
	public static int g(int n){//非递归
		int number=1;
		if(n==0){
			return 1;
		}
		for (int i = 1; i <=n; i++) {
			number=number*i;
		}
		return number;
	}
}

倒序输出一个正整数：

例如给出正整数 n=12345，希望以各位数的逆序形式输出，即输出54321。

递归思想：首先输出这个数的个位数，然后再输出前面数字的个位数，直到之前没数字。

public class Mains{
	public static void main(String[] args) {
		int n=12345;
		f(n);
		System.out.println();
		g(n);
		System.out.println(h(n));
	}
	public static int f(int n){//递归
		if(n<10){
			System.out.print(n%10+" ");
			return -1;
		}else{
			System.out.print(n%10+" ");
			return f(n/10);
		}
	}
	public static void g(int n){//迭代
		while(n>0){
			System.out.print(n%10+" ");
			n=n/10;
		}
		System.out.println();
	}
	public static int h(int n){//字符串
		String str=""+n;
		StringBuffer sb=new StringBuffer(str);
		str=new String(sb.reverse());
		n=Integer.valueOf(str);
		return n;
	}
}

最大公约数求法：

辗转相除法，是求最大公约数的一种方法。它的具体做法是：用较大数除以较小数，再用出现的余数（第一余数）去除除数，再用出现的余数（第二余数）去除第一余数，如此反复，直到最后余数是0为止。如果是求两个数的最大公约数，那么最后的除数就是这两个数的最大公约数。

public class Mains{
	public static void main(String[] args) {
		System.out.println(f(15,6));
	}
	public static int f(int n,int m){
		if(m==0){
			return n;
		}else{
			return f(m,n%m);
		}
	}
}

二分查找的递归形式：

import java.util.Arrays;

public class Mains{
	public static void main(String[] args) {
		int a[]={4,5,6,2,3};
		Arrays.sort(a);
		System.out.println(Arrays.toString(a));
		int index=f(a, 0, a.length-1, 6);
		if(index==-1) System.out.println("no find");
		else System.out.println(index);
	}
	public static int f(int a[],int left,int right,int number){
		if(left>right){
			return -1;
		}
		int mid=(left+right)/2;
		if(a[mid]==number){
			return mid;
		}else if(a[mid]<number){
			return f(a,mid+1,right,number);
		}else{
			return f(a, left, mid-1, number);
		}
	}
}

插入排序递归形式：

public static void f(int a[],int n){
		if(n==0) 
		return ;
		f(a,n-1);
		for (int i = 0; i < n; i++) {
			if(a[n]<a[i]){
				swap(a, n, i);
			}
		}
	}

小白上楼梯问题：楼梯有n阶，一次可以上1，2，3阶，如果有n阶楼梯，有多少种上法。

思路：从后往前想，上n阶可以分为三种，还有n-1阶楼梯，还有n-2阶楼梯，以及还有n-3阶楼梯，把这三种情况的种数相加，就是总走法：

具体代码如下：

public class Mains{
	public static void main(String[] args) {
		int a=f(4);
		System.out.println(a);
	}
	public static int f(int n){
		if(n==1) return 1;
		else if(n==2) return 2;
		else if(n==3) return 4;
		return f(n-1)+f(n-2)+f(n-3);
	}
}

设计一个高效的a的n次幂算法：

public class Mains{
	public static void main(String[] args) {
		System.out.println(f(3, 10));
		
	}
	public static int f(int a,int n){
		if(n==0) return 1;
		int res=a;
		int exp=1;
		while(exp*2<=n){
			res=res*res;
			exp*=2;
		}
		return res*f(a, n-exp);
	}
}

 

小节：

1. 找重复

找到一种划分方法

找到递推公式或者等价转换

都是父问题转化为子问题

1. 找变化的量

变化的量一般作为参数

1. 找出口

参数变化的临界值、

喜欢的记得点个关注哟！