汉诺塔和跳台阶问题

Java重载

重载的规则

• 方法名相同
• 方法参数不同(参数类型或参数个数)
• 方法的返回值类型不影响重载

代码示例：

重载add()方法，实现整数和小数的加法

import java.util.*;
public class TestDemo{
	public static void main(String[] args) {
        //两个整数
		Scanner sc =new Scanner(System.in);
		int a =sc.nextInt();
		int b =sc.nextInt();
		System.out.println(add(a,b));
		//两个浮点数
		double x = sc.nextDouble();
		double y = sc.nextDouble();
		System.out.println(add(x,y));
		//两个整数和一个浮点数
		int r = sc.nextInt();
		int p = sc.nextInt();
		double q = sc.nextDouble();
		System.out.println(add(r,p,q));
		//整数和浮点数
		int m = sc.nextInt();
		double n = sc.nextDouble();
		System.out.println(add(m,n));
		sc.close();
	}
    
	private static int add(int a,int b) {
			return a + b;
	}
	private static double add(double a,double b) {
		return a + b;
	}
    
    //返回值类型并不影响重载
	private static double add(int a,int b,double c) {
		return a + b + c;
	}
	private static double add(int a,double b) {
		return a + b;
	}
}

递归

一个方法在执行过程中调用自身就叫做递归

例如，在数学中我们求某个数的阶乘时。很容易知道当N =1 时，1！就是1，这个条件在递归中称为结束条件

递归公式：求N！时，我们可以将其化解为N！=N*(N - 1)!

代码示例：递归求N的阶乘

	public static int fac(int n) {
		if (n == 1 || n == 0) { //当输入n为1 时输出1，n为时输出0
			return n;
		}
		return n * fac(n - 1);  //然后根据N！=N*(N - 1)! ,递归计算N！
	}

要清楚理解递归，必须先理解方法执行的结束条件，以及方法调用的位置。

递归可以有效地简化方法的代码，但是递归的效率并不是最高的，可以自行验证。

例：求斐波那契数列的第n项

//递归解决
		public static int fibo(int n) {
		if (n == 1 ) {
			return n;
		}
		if (n == 0) {
			return 0;
		}
		return fibo(n - 1) + fibo(n - 2);
	}
//输入5 输出5
//1 1 2 3 5 8

//迭代解决
	public static int fibo(int n) {
		int f1 = 1;
		int f2 = 1;
		if (n == 1 || n == 2) {
			return 1;
		}
		int f3 = 0;
		for (int i = 3;i <= n ;i++ ) {
			f3 = f1 + f2;
			f1 = f2;
			f2 = f3;
		}
		return f3;
	}
//输入5 输出 5

用递归解决问题

1、汉诺塔问题

有三个柱子A,B,C。A柱子上放有N个圆盘，规定任何时候小圆盘不能在大圆盘上，且在三根柱子之间一次只能移动一个圆盘，请问如何移动，才能把所有圆盘从A移到C。

import java.util.Scanner;
public class Hanio{
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		HanioTower(n,'A','B','C');
	}
	private static void move(char a,char b){
			System.out.print(a+"->"+b+" ");
	}

	private static void HanioTower(int n,char a,char b,char c) {
		if (n == 1) {  //结束条件，当只剩一个盘子时，从A->C
			move(a,c);
			return ;
		}
		HanioTower(n - 1,a,c,b);  //先把n-1个盘子，从A移到B  借助c
		move(a,c);  //剩下第n个盘子，从A移到C
		HanioTower(n - 1,b,c,a); //然后把n-1个盘子，从B移到A  借助c
	}
}

2、跳台阶问题

青蛙跳台阶问题，有一个n阶的台阶，青蛙每次只能跳一阶或者两阶，请问一共有多少种跳法？

public class FrogJump{
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		sc.close();
	}
	private static int frogJump(int n) {
			if (n == 1 ) {
				return 1;
			}
			if (n == 2) {
				return 2;
			}
			return frogJump(n -1)+ frogJump(n -2);
	}
}
//可以发现，青蛙跳台阶的方法数和斐波那契数列一致
//1 2 3 5 8 13....

可以发现青蛙跳台阶的方法数与斐波那契数列一致，因此可以使用迭代来解决跳台阶问题

	private static int frog(int n) {
		int f1 = 1;
		int f2 = 2;
		int f3 = 0;
		for (int i = 3;i <= n ;i++ ) {
			f3 = f1 + f2;
			f1 = f2;
			f2 = f3;
		}
		return f3;
	}
}

进阶：变态跳台阶

青蛙一次可以跳任意阶台阶

	private static int FrogJumpPro(int n) {
		if (n == 0||n == 1 ) {
			return n;
		}

		int res = 0;
		for (
			int i = 0;i < n ;i++ ) {
			res = res +hentaiJump(i);
		}
		return res + 1;
	}
//输入5  输出 16