汉诺塔问题是比较常见且经典的使用递归解决的问题。

那什么是汉诺塔呢？

汉诺塔源自古印度的传说，源于印度一个古老传说。

大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。

大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，任何时候，在小圆盘上都不能放大圆盘，且在三根柱子之间一次只能移动一个圆盘。

通俗讲：总共有三根柱子A、B、C，开始在柱子A上从上到下按从小到大的顺序摞着64片盘子，把A上的所有盘子按照从小到到大的顺序放到C柱子上，而且任何时候在小圆盘上都不能放大圆盘，且在三根柱子之间一次只能移动一个圆盘。

——————————————————————————————————————————————————————————————————

现在拿三个盘子举栗子！！！

注意：

下面我们就来进行分析：

首先，我们要有一个概念，在开始移动的时候，我们把最下面的盘子看作一个整体，其余上面的看作一个整体。

由下图中三个盘子实现A到C，先把上面两个盘子看作整体使都能到B（原始到步骤1，注：因为一次只能移动一个，而且小的在上，所以上面的两个盘子先到C再到B实现上面两个整体到B柱），之后让最大的盘子从A到C，然后再让B上的盘子整体从B到A再到C实现所有盘子的移动（步骤2到步骤3的内部移动）。

所以根据上图我们可以总结出规律

当A柱放一个盘子的时候移动规律为：

A到C

当A柱放两个盘子（两个盘子简单所以没画，嘻嘻！）的时候移动规律为：

A到B
A到C
B到C

当A柱放三个盘子移动规律为：

A到B

{上面两个看作整体，从上图紫框中：上面两个从A到B要经历A到C再从C到B}

**A到C

{步骤1到步骤2}

B到C

{ 上图绿框中的步骤，经历B到A再到C}**

类比下来，如果有四个盘子，第一步：先将上面三个看作一个整体，先让上面三个经过A到C再到B实现三个整体到B，

之后：再让最大的第四个盘子到C，

然后呢，再让B上面的三块整体通过一些内部操作，经历B到A最后再到C。

————————————————————

那对n个盘子先对上面n-1个整体经过一些操作从A移动到B，再移动第n个到C，之后再将n-1个整体从B经过一些操作移动到C

—————————————————————
上代码图！

代码：

import java.util.Scanner;
public class hanoiTower {
    public static void main(String[] args) {
        System.out.println("输入要移动盘子的个数：");
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        char A = 'A';
        char B = 'B';
        char C = 'C';
        System.out.println("需要的步骤为：");
        hanoi(n,A,B,C);
    }
    public static void move(char A , char C){
           System.out.println(A+"->"+C);
    }
    public static void hanoi(int n , char A , char B , char C){
        if (n==1){
            move(A , C);
        }else{
            hanoi(n-1 , A , C , B);
            move(A , C);
            hanoi(n-1 , B , A , C);
        }
    }
}

测试:

青蛙跳台阶

一只青蛙一次可以跳上 1 级台阶，也可以跳上2 级。求该青蛙跳上一个n 级的台阶总共有多少种跳法。

由下图可以发现规律，从第三个台阶开始，每层台阶跳法等于前两层台阶跳法之和。eg：台阶级数为6时，青蛙跳台阶的方法有5+8=13种。

可以类比裴波那契数列：sum=f(n-1)+f(n-2)

上代码！！！

递归：

import java.util.Scanner;
public class frogSeat {
    public static void main(String[] args) {
        System.out.println("输入青蛙要跳的台阶数：");
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int sum = jump(n);
        System.out.println("青蛙有"+sum+"种跳法！");
    }
    public static int jump(int n){
        int sum = 0 ;
        if(n==0){
            return 0 ;
        }else if(n<=2){
            return n ;
        }else{
            sum = jump(n-1)+jump(n-2);
        }
        return sum ;
    }
}
测试：
输入青蛙要跳的台阶数：
10
青蛙有89种跳法！

非递归：

1、使用变量

import java.util.Scanner;
public class frogSeat {
        public static void main(String[] args) {
            System.out.println("输入青蛙要跳的台阶数：");
            Scanner sc = new Scanner(System.in);
            int n = sc.nextInt();
            int sum = jump(n);
            System.out.println("青蛙有"+sum+"种跳法！");
        }
        public  static int jump(int n){
            int i = 1 ;
            int j = 2 ;
            int k = 0 ;
            if (n==0){
                return 0 ;
            }else if(n<=2) {
                return n ;
            } else{
                for (int a = 3 ; a<=n ; a++){
                    k = i+j ;
                    i=j;
                    j=k;
                }
                return k ;
            }
        }
    }
测试：    
输入青蛙要跳的台阶数：
6
青蛙有13种跳法！

2、使用数组

import java.util.Scanner;
public class frogSeat {
    public static void main(String[] args) {
        System.out.println("输入青蛙要跳的台阶数：");
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        jump(n);
    }
        public  static void jump(int n) {
        int []funArrays = new int[999];
        funArrays[0] = 1;
        funArrays[1] = 2;
        int j = 0 ;
        if (n == 1) {
            System.out.println("方法有"+ funArrays[0]+"种！");
        }
        if (n == 2) {
            System.out.println("方法有"+ funArrays[1]+"种！");
        }else {
            for (j = 2; j <= n-1; j++) {
                funArrays[j]=funArrays[j-1]+funArrays[j-2];

            }
            System.out.println("方法有"+ funArrays[n-1]+"种！");
        }
     }
}