Java详解斐波那契数列，及汉诺塔。

斐波那契数列

斐波那契数列以如下被以递推的方法定义：F(0)=0，F(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 2，n ∈ N*）。
指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……

1.非递归方法（循环）

 public static long fib(int n) {
        if(n == 0){
            return 0;
        }
        long f1 = 1;
        long f2 = 1;
        long f3 = 1;
//此处不难由递推公式理解：由公式可知F(n)=F(n-1)+F(n-2)
        for (int i = 3; i <= n ; i++) {
            f3 = f1 + f2;
            f1 = f2;
            f2 = f3;
        }
        return f3;
    }

    public static void main(String[] args) {

        System.out.println(fib(0));
        System.out.println(fib(1));
        System.out.println(fib(2));
        System.out.println(fib(3));
        System.out.println(fib(4));
        System.out.println(fib(5));
        System.out.println(fib(50));

    }

2.递归方法

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

    public static void main(String[] args) {
        //System.out.println(func());

        System.out.println(fib(0));
        System.out.println(fib(1));
        System.out.println(fib(2));
        System.out.println(fib(3));
        System.out.println(fib(4));
        System.out.println(fib(5));
        System.out.println(fib(50));	//这里50用递归运算量非常巨大编译器会计算很久没反应，不是程序错误。
        //System.out.println(max(1, 2, 3));
    }

简单解释（方便起见，这里用n=4，其他逻辑相同）：

注：递归方法虽然较容易理解但计算量很大，从程序的运算效率来看，循环的效果更优于递归。

下面由代码进行简单了解：

public class text {
    public static int count;
    public static void main(String[] args) {
        System.out.println(fib(40));
        System.out.println(count);
    }
    public static int fib(int n){
        if(n == 1 || n == 2){
            return 1;
        }
        if(n == 3){		//这里记录n=3时递归调用了几次
            count++;
        }
         return fib(n-1)+fib(n-2);
    }

如上可知：fib(40)中n=3调用了3千多万次，不难说明效率很低。

汉诺塔

游戏介绍：
圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

如图所示：

通过思考不难发现由以下移动方式即可成功：
A->C A->B C->B A->C B->A B->C A->C 。

在这里，我们可以将三个底座分别定义为：起始底座A，中转底座B，终点底座C。
代码实现如下：

    /**
     *
     * @param pos1  //起始位置
     * @param pos2  //中转位置
     * @param pos3  //最终位置
     * @param n
     */
    public static void HanNuo(int n,char pos1,char pos2 ,char pos3){
        if(n == 1){
            move(pos1,pos3);    //若只有一个盘子从起始直接到最终
            return;
        }
        
        //除最底下一个盘子，将其他盘子通过最终位置移动到中转位置。
        HanNuo(n-1,pos1,pos3,pos2);
        move(pos1,pos3);    //将最后一个盘子移动到最终位置

        //将剩下的盘子通过中转->起始->最终
        HanNuo(n-1,pos2,pos1,pos3);
    }

    public static void move(char pos1,char pos2){
        System.out.print(pos1 +"->"+ pos2+ " ");
    }

    public static void main(String[] args) {
        HanNuo(1,'A','B','C');
        System.out.println();	//打印回车
        HanNuo(2,'A','B','C');
        System.out.println();	//打印回车
        HanNuo(3,'A','B','C');
    }

下面对代码进行简单分析（用n=3）：

结果如下：

上述的分析过程可以细细看过后自己也画一遍，便于自己理解加深印象。代码看似很短很简单，但是理解起来还是很有难度。可以先有一个笼统的概念，就是，始终先将最后一个盘放到最终底座上，然后将其他的盘通过中转底座，借助初始底座向最终底座转移。