递归

递归

1. 递归的概念

简单的说：递归就是方法自己调用自己，每次调用时传入不同的变量.递归有助于编程者解决复杂的问题，同时可以让代码变得简洁。

1. 递归调用机制
   • 1 打印问题
   • 2 阶乘问题
2. 使用图解的方式说明递归的调用机制
   
3. 递归能解决什么样的问题
   1）各种数学问题如：8皇后问题，汉诺塔，阶乘问题，迷宫问题，球和篮子的问题（google 编程大赛）
   2）各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等3）将用栈解决的问题–>第归代码比较简洁
4. 递归需要遵守的重要规则
   1）执行一个方法时，就创建一个新的受保护的独立空间（栈空间）
   2）方法的局部变量是独立的，不会相互影响，比如n变量
   3）如果方法中使用的是引用类型变量（比如数组），就会共享该引用类型的数据.
   4）递归必须向退出递归的条件逼近，否则就是无限递归，出现StackOverflowError，死循环了）
   5）当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕

2. 迷宫问题

小球得到的路径，和程序员设置的找路策略有关即：找路的上下左右的顺序相关

/**
 * 用迷宫小游戏来进行演示递归
 */
public class MiGong {
    public static void main(String[] args) {
        //定义一个8行7列的迷宫  1.表示墙  2.表示已走过  3.表示走不通
        int[][] map = new int[8][7];
        //定义上下墙
        for (int i = 0; i < 7; i++) {
            map[0][i] = 1;
            map[7][i] = 1;
        }
        //定义左右墙
        for (int i = 0; i < 8; i ++) {
            map[i][0] = 1;
            map[i][6] = 1;
        }
        //定义中间隔板
        map[3][1] = 1;
        map[3][2] = 1;
//        map[1][2] = 1;
//        map[2][2] = 1;

        //输出地图
        System.out.println("地图情况");
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }

        //使用递归回溯法走小迷宫
        new MiGong().getWay(map, 1, 1);

        //输出地图
        System.out.println("使用递归回溯法的地图情况");
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }
    }

    //使用递归回溯来给小球找路
    /*
    思路：
        1.map表示地图
        2.i，j表示从地图的哪个位置开始出发（1，1）
        3.如果小球能到map[6][5]位置，则说明通路找到。
        4.约定：当map[i][j]为0表示该点没有走过当为 1表示墙；2表示通路可以走；3表示该点已经走过，但是走不通
        5.在走迷宫时，需要确定一个策略（方法）下->右->上->左，如果该点走不通，再回溯
     */
    /**
     * 使用递归回溯来给小球找路
     * @param map 表示地图
     * @param i   表示从哪个位置开始找，行的值
     * @param j   列的值
     * @return  如果找到通路，就返回true，否则返回false
     */
    private boolean getWay(int[][] map,int i,int j) {
        //终点在7行6列的位置
        if (map[6][5] == 2) {   //通路已经找到ok
            return true;
        } else {
            if (map[i][j] == 0) {   //如果当前这个点还没有走过
                map[i][j] = 2;     //假定该位置可以走
//            确定一个策略（方法）下->右->上->左，如果该点走不通，再回溯
                if (getWay(map, i + 1,j )) {
                    //向下走
                    return true;
                } else if (getWay(map, i,j + 1 )) {
                    //向右走
                    return true;
                } else if (getWay(map, i - 1,j )) {
                    //向上走
                    return true;
                } else if (getWay(map,i ,j -1 )) {
                    //向左走
                    return true;
                } else {
                    //如果都走不通，设置为3
                    map[i][j] = 3;
                    return false;
                }
            } else {
                return false;
            }
        }
    }
}

3. 八皇后问题（回溯算法）

1. 八皇后问题介绍
   八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法（92））
   

2. 八皇后问题算法思路分析
   1）第一个皇后先放第一行第一列
   2）第二个皇后放在第二行第一列、然后判断是否OK，如果不OK，继续放在第二列、第三列、依次把所有列都放完，找到一个合适
   3）继续第三个皇后，还是第一列、第二列……直到第8个皇后也能放在一个不冲突的位置，算是找到了一个正确4）当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解，全部得到.
   5）然后回头继续第一个皇后放第二列，后面继续循环执行1，2，3，4的步骤

3. 思路示意图：
   

4. 说明
   理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题.ar[8]={0，4，7，5，2，6，1，3}//对应arr下标表示第几行，即第几个皇后，arr[i]=val，val表示第i计1个皇后，放在第i计1行的第val+1列

5. 代码实现

   public class Queue8 {
       //定义一个max表示共有多少个皇后
       int max = 8;
       //定义数组array，保存皇后放置位置的结果，比如 arr = {0,4,7,5,2,6,1,3}
       int[] arr = new int[8];
       static int count = 0;   //表示有多少种方法
       static int judgeCount = 0;  //判断冲突的次数
   
       public static void main(String[] args) {
           Queue8 queue8 = new Queue8();
           queue8.check(0);
           System.out.printf("一共有%d种解法\n",count);
           System.out.printf("一共判断%d次冲突\n",judgeCount);
       }
   
   
       //编写一个方法，放置第n个皇后
       //特别注意：check 是每一次递归时，进入到check中都有 for (int i = 0; i < n; i++)
       private void check(int n) {
           if (n == max) {     //n==8，说明8个皇后都已经无冲突的放好,n==8相当于正在放第9个皇后了，所以要停止返回
               print();
               return;
           }
   
           //一次放入皇后，并判断是否冲突
           for (int i = 0; i < n; i++) {
               //先把当前这个皇后n，放到改行的第1列
               arr[n] = i;     //⑤
               //判断当前放置第n个皇后到第i列时，是否冲突
               if (judge(n)) {     //不冲突
                   //接着放n+1个皇后，即开始递归
                   check(n+1);
               }
               //如果冲突，就继续执行array[n] = i;即将第n个皇后，放置在本行的下一位置（也就是执行上述⑤，但是此时i = i+1）
           }
       }
   
   
       /**
        * 查看我们放置第n个皇后，就去检测皇后是否和前面已经摆放的皇后冲突
        * @param n 表示第几个皇后
        * @return
        */
       private boolean judge(int n) {
           judgeCount++;
           for (int i = 0; i < n; i++) {
               /**
                * 说明：
                * arr[i] == arr[n] 表示判断 第n个皇后是否和前面的n-1个皇后在同一列
                * Math.abs(n-i) == Math.abs(arr[n] - arr[i]) 表示判断两个皇后的横向距离和纵向距离是否相等
                */
               if (arr[i] == arr[n] || Math.abs(n-i) == Math.abs(arr[n] - arr[i])) {
                   return false;
               }
           }
           return true;
       }
   
       //写一个方法，可以将皇后白方的位置输出
       private void print() {
           count++;
           for (int i = 0; i < arr.length; i++) {
               System.out.print(arr[i]+" ");
           }
           System.out.println();
       }
   }
   
   

4. 汉诺塔问题

1. 说明：将所有的盘子从塔1移动到塔3，每次只能移动一个盘子。
   游戏最重要的规则：是大的盘子不能放在小的盘子上面
   
2. 思路：
   1）当只有一个盘子时，直接将盘子从塔1移动到塔3
   2）当有n个盘子时，(递归思想)：他的最后一步都是：
   • 将 n-1 个盘子从塔1 移动到 塔2，
   • 然后将最大的盘子从塔1 移动到 塔3
   • 再将 n-1 个盘子从塔2 移动到 塔3
3. 示意图
   将 n-1 个盘子从塔1 移动到 塔2
   然后将最大的盘子从塔1 移动到 塔3
   再将 n-1 个盘子从塔2 移动到 塔3
   
4. 代码实现

public class Hanoi {

    public static void main(String[] args) {
        new Hanoi().getWay(4, 'A','B' ,'C' );
    }

    /**
     * 汉落塔问题的解决方案
     * @param n 表示总共有几个盘子
     * @param A 表示A盘子
     * @param B 表示B盘子
     * @param C 表示C盘子
     */
    private void getWay(int n,char A,char B, char C) {
        if (n == 1) {
            //只有一个盘子（直接从A移动到C）
            System.out.println(A + "--->" + C);
        } else {    //第一个位置表示盘子的位置，最后第三盘子表示移动的地方（参考上面的n==1时候）
            getWay(n-1,A ,C ,B ); //将前n-1个盘子从A移动到B上
            System.out.println(A + "--->" + C);     //将最后一个盘子从A移动到C上
            getWay(n-1,B ,A ,C );    //再将n-1个盘子从B移动到C
        }
    }
}