（三）递归算法（Java实现斐波拉契数列、文件夹遍历、八皇后）

我对递归解释就是：一个有名字有参数的方法自己调用自己！

若想对递归有深层次的了解，就需要知道——递归调用过程中什么时候到上一层！！！

看下面三个例子：

1.用递归算法实现斐波拉契数列：

public class Recursion {
    //########求Fibonacci数列：1,1,2，3,5,8，...第40个数的值。数列满足递推公式：F1=1，F2=1,Fn=Fn-1+Fn-2。
   //用递归的方法
    public static long fibonacci(int n) {
        if(n==1 || n==2) {
            return 1;
        }
        else {
            return fibonacci(n-1)+fibonacci(n-2);
        }
    }

    //用普通方法实现
    public static long fibonacci2(int index) {
        long f1=1, f2=1 ,f=0;
        if(index < 1) {
            System.out.println("输入的数据不合法！请输入比1大的整数！");
            return -1;
        }
        if(index==1 || index==2) {
            return 1;
        }else {
            for(int i=1; i<index-2; i++) {
                f = f1 + f2;
                f1 = f2;
                f2 = f;
            }
            return f;
        }
    }

    public static void main(String[] args) {
        int x = 40;
        long n = (long)(fibonacci(x));
        long n2 = (long)(fibonacci2(x));
        System.out.println("递归方法计算出的Fibonacci数列中第"+x+"个数是："+n);
        System.out.println("普通方法计算出的Fibonacci数列中第"+x+"个数是："+n);
    }
}

   显然用递归算法实现斐波拉契数列代码很简洁，但是参数值相当大的时候，占用内存和时间是相当大的（不信的话，传入10000，可以测测电脑的性能，看电脑要运行多久）。

    不过用递归算法实现树的遍历的性能是很好的，文件夹结构就是很典型的树的结构。

2.递归遍历文件夹

看下例：

import java.io.File;

public class ShowFilesDir {
    public static void main(String[] args) {
    File f = new File("E:/SchoolWork"); //要遍历的文件夹
    System.out.println(f.getName());
    tree(f,1);
    }

    public static void tree(File f, int level) {
        String preStr = "";
        for(int i=0; i<level; i++){
            preStr += "——";
        }
        File[] childs = f.listFiles();
        for(int i=0; i<childs.length; i++) {
            System.out.println(preStr+childs[i].getName());
            if(childs[i].isDirectory()) {
                tree(childs[i],level+1);
            }
        }
    }
}

3.递归实现“八皇后”

package com.review07;

/**
 * 递归算法最关键的是：递归过程中什么时候到上一层
 * 国际象棋中的八皇后问题：
 * 在8X8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。
 */
public class EightQueen {

    static int[][] map = new int[8][8]; //表示8*8棋盘，0表示没有皇后，1表示放了皇后
    static int count = 1; //摆放方法总数
    //显示棋盘
    public static void show() {
        System.out.println("第"+count+"种摆法");
        count ++;

        for(int i=0; i<8; i++) {
            for(int j=0; j<8; j++) {
                System.out.print(map[i][j]+"  ");
            }
            System.out.println();
        }
    }

    public static boolean check(int row, int col) {
        //正上面(行减小，列不变)
        for(int i=row-1; i>=0; i--) {//当row=0时，即第一行，i=-1，不满足，下面几个for也不满足，直接返回true
            if(map[i][col] == 1) {
                return false;
            }
        }
        //左斜上(行减小，列减小)
        for (int i=row-1,j=col-1; i>=0 && j>=0; i--,j--) {
            if(map[i][j] == 1) {
                return false;
            }
        }
        //右斜上(行减小，列增加)
        for (int i=row-1,j=col+1; i>=0 && j<8; i--,j++) {
            if(map[i][j] ==1) {
                return false;
            }
        }
        return true;
    }

    public static void play(int row) {
        //遍历当前行的所有单元格
        for(int i=0; i<8; i++) {
            if(check(row,i)) { //能够放皇后
                map[row][i] =1; //设置皇后
                if(row == 7) { //如果是最后一行，就显示
                    show();
//                    map[row][i] = 0;//关键代码
                }else { //否则，在下一行设置皇后
                    play(row+1);
                    //当调用自己结束时，去掉当前设置的皇后
//                    map[row][i] = 0;//去皇后。关键代码
                }
                map[row][i] = 0;//关键代码
            }
        }
    }

    public static void main(String[] args) {
        play(0);
    }
}

              

                 。。。。。。                            

        

共92种摆法！

 

看下面的分析图：

8*8的太大了，这里换成了4*4的，相当于是“四皇后”，上图是for循环一次下来的调用过程，→表示调用play方法，←表示调用play方法向前走了之后行不通，不能继续往前走了，要返回到上一层了，这里是难点。

4*4的只有两种即：

通过这个例子应该对递归的认识不仅仅只是自己调用自己那么简单，什么时候不再调用自己，还有就是什么时候返回，这些问题更为重要！