递归

递归 

程序每执行到一个方法时，会开辟一个独立的空间（栈）。

方法的局部变量独立。

方法中使用的是引用类型变量，则会共享该引用类型的数据。多个栈共享同一个数组。

递归必须向退出递归的条件逼近。否则栈溢出。

应用场景

数学问题：8皇后问题，汉诺塔，迷宫，秋和篮子

算法问题：快排，归并排序，二分查找，分治算法

使用栈解决的问题

八皇后问题

第一个皇后放第一行第一列，第二个皇后放第二行第一列，判断是否ok,不ok,继续第二列，第三列...

直到第8个皇后也能放在一个不冲突的位置，则是找到了一个正确解。

得到正确解时，在栈回退到上一个栈时，就会开始回溯，将第一个皇后，放到第一列的所有正确解，全部得到

回头继续第一个皇后放第二列，循环上述步骤。

package 递归;

import java.util.Queue;

public class Queue8 {
    int max=8;
    int[] array=new int[max];//递归共享一个数组
    static int count=0;
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //arr[i]=val val表示第i+1个皇后，放在第i+1行的第val+1列
        Queue8 queue8=new Queue8();
        queue8.check(0);
        System.out.println(count);
        };
        
    
    //放置第n个皇后；check每一次递归，都循环8次 回溯
    private void check(int n) {
        if(n==max) {//前8个已经放好了
            print();
            return;
        }
        //依次放皇后
        for(int i=0;i<max;i++) {
            //先放到第一列
            array[n]=i;
            //判断是否冲突
            if(judge(n)) {
               check(n+1);//
            }
            //如果冲突，继续执行array[n]=i
        }
    }
    //查看放置第n个皇后，检查该皇后是否和前面已经摆放的冲突
    private boolean judge(int n) {
        for(int i=0;i<n;i++) {
            //判断是否在同一列 同一斜线
            if(array[i]==array[n]||Math.abs(n-i)==Math.abs(array[n]-array[i])) {
                return false;
            }
        }
        return true;
    }
      //写一个方法，将皇后摆放的位置输出
    private void print() {
        count++;
        for(int i=0;i<array.length;i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }
}

 

迷宫问题 

public class 递归 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //二维数组表示地图
        int[][] map=new int[8][7];
        //使用1表示墙 上下全部置为1
        for(int i=0;i<7;i++) {
            map[0][i]=1;
            map[7][i]=1;
        }
        //左右全部置为1
        for(int i=0;i<8;i++) {
            map[i][0]=1;
            map[i][6]=1;
        }
        //设置挡板
        map[3][1]=1;
        map[3][2]=1;
        //输出地图
        for(int i=0;i<8;i++) {
            for(int j=0;j<7;j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }
        //使用
        setWay(map, 1, 1);
        //输出
        for(int i=0;i<8;i++) {
            for(int j=0;j<7;j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }
    }
       //使用递归回溯找路
    //i j从哪个位置出发；map[6][5]通路找到；约定：当map[i][j]0未走过 2表示可以走 3已经走过，但是不通
    //需要确定策略：下》右》上》左；如果走不通，回溯
    public static boolean setWay(int[][] map,int i,int j) {
        if(map[6][5]==2) {//通路已经找到
            return true;
        }else {
            if (map[i][j]==0) {
                //按照策略走
                map[i][j]=2;//假定可以走
                if(setWay(map, i+1, j)) {//向下走
                    return true;
                }else if(setWay(map, i, j+1)){//向右走
                    return true;
                }else if(setWay(map, i-1, j)) {//向上走
                    return true;
                }else if(setWay(map, i, j-1)) {//向左走
                    return true;
                }else {//走不通
                    map[i][j]=3;
                    return false;
                }
            }else {//map可能是1，2，3
                return false;    
            }
        }