数据结构与算法（三）（递归）

递归

递归的调用机制

1.概念
简单来说，就是方法自己调用自己，每次调用时传入不同的变量
2.案例解析

package test;

public class Test {
    public static void main(String[] args) {
        test(4);
    }

    public static void test(int n ){
        if(n>2){
            test(n-1);
        }
        System.out.println(n);
    }
}

输出结果为：2 3 4

递归可以解决的问题

1.各种数学问题，比如：8皇后问题，汉诺塔，阶乘问题，迷宫问题
2.算法中，比如：快速排序，归并排序，二分查找，分治算法
3.用栈解决的问题，也可以使用递归

递归需要遵守的基本规则

1.执行一个方法时，就创建一个新的受保护的独立空间（栈空间）
2.方法的局部变量是独立的，不会互相影响
3.如果方法中使用的是引用类型变量，就会共享该数据
4.递归必须逐渐向退出递归的条件接近
5.当一个方法执行完毕，或者遇见return，就会返回，遵循谁调用，就返回给谁的原则

迷宫问题代码实现

找出迷宫的通路，原则是先看下面是不是通路，再看右面，再看上面，最后看左面，使用递归实现

package recursion;

public class MiGong {
    public static void main(String[] args) {
        //创建迷宫
        int[][] migong = new int[8][7];
        for(int i=0;i<7;i++){
            migong[0][i] = 1;
            migong[7][i] = 1;
        }
        for(int i=0;i<8;i++){
            migong[i][0] = 1;
            migong[i][6] = 1;
        }
        migong[3][1] = 1;
        migong[3][2] = 1;
        //看一下迷宫
        for(int i=0;i<8;i++){
            for(int j=0;j<7;j++){
                System.out.print(migong[i][j]+" ");
            }
            System.out.println();
        }
        System.out.println();
        MiGong mg = new MiGong();
        mg.maze(migong,1,1);
        for(int i=0;i<8;i++){
            for(int j=0;j<7;j++){
                System.out.print(migong[i][j]+" ");
            }
            System.out.println();
        }
    }

    //迷宫问题
   //1表示墙，2表示通路，3表示走过啦但是走不通
    public boolean maze(int[][] migong,int beginx,int beginy){
        if(migong[6][5] == 2){
            return true;
        }else {
            if(migong[beginx][beginy] == 0){
                migong[beginx][beginy] = 2;
                if(maze(migong, beginx+1, beginy)){
                    return true;
                }else if(maze(migong, beginx, beginy+1)){
                    return true;
                }else if(maze(migong, beginx-1, beginy)){
                    return true;
                }else if(maze(migong, beginx, beginy-1)){
                    return true;
                }else{
                    migong[beginx][beginy] = 3;
                    return false;
                }
            }else{
                return  false;
            }
        }
    }
}

8皇后问题

1.问题描述
在一个8*8的国际象棋上，摆上8个皇后，使其不能相互攻击，即：任意两个皇后都不能处于同一行，同一列，同一斜线上，问有多少种摆法？
2.问题分析
a.第一个皇后放在第一行第一列
b.第二个皇后放在第二行第一列，看是否满足条件，如果不满足再将其放在第二行第二列，第三列，第四列…找到一个合适的位置
c.继续放置第三行的皇后，依旧是第二列，第三列…直到把8行全部放完
d.此时找到啦一个正确的解法，此时开始回溯，回溯结束就可以找到第一个皇后放在第一行第一列的全部解法
e.此时将第一个皇后放在第一行第二列上，重复bcd过程
3.需要注意的问题
解决此问题，可以使用一个二维数组，但是使用一维数组更为简单，arr[8] = {0,4,7,5,2,6,1,3},arr[i]=var,此时val表示第i+1个皇后，放在i+1行val+1列上
4.代码实现

package recursion;

public class Queue8 {
    public static void main(String[] args) {
        Queue8 queue8 = new Queue8();
        queue8.addQueue(0);
    }
    //创建一个数组
    int[] array = new int[8];

    //打印这个数组
    public void showArray(){
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }

    //判断此处是否可以放置皇后
    //n表示第几行,n从0开始
    //当第一次找到满足条件的时候，从第7行开始回溯，这时会把第7行剩下的继续遍历，遍历结束会从第6行回溯，执行时，会影响第6行和第7行，同理第5行会影响第6，7行
    public boolean judge(int n){
        for(int i=0;i<n;i++){
            //array[i]==array[n]比较是否在一列上
            //Math.abs(n-i) == Math.abs(array[i]-array[n]) 比较是否在一条斜线上
            if(array[i]==array[n] || Math.abs(n-i) == Math.abs(array[i]-array[n])){
                return false;
            }
        }
        return true;
    }

    //添加皇后
    //n代表放在第几行
    public void addQueue(int n){
        //如果n为8，那么就找到啦一组
        if(n==array.length){
            showArray();
            return;
        }
        for(int i=0;i<array.length;i++){
            array[n] = i;
            if(judge(n)){
                addQueue(n+1);
            }
        }
    }
}