5-递归

递归

---

基本介绍

直接或间接 自己调用自己

当递归运行到一个方法时 会开启一个独立的栈

规则

执行一个方法时，就创建--个新的受保护的独立空间(栈空间)
方法的局部变量是独立的，不会相互影响
递归必须向退出递归的条件逼近，否则就是无限递归，死龟了:) StackOverFlow 栈溢出 错误
当一个方法执行完毕，或者遇到return， 就会返回，遵守谁调用，就将结果
返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

应用

迷宫问题

package com.company.recursion;

/**
 * @Function :
 * date 2021/5/14 - 23:09
 * How :
 */
public class Maze {
    public static void main(String[] args) {
        //生成地图
        int[][] map = createMap();
        //输出地图
        printMap(map);
        //
        int[] target = {12,12};
        boolean flag = searchPath(map, 1, 1);
        System.out.println(flag);
    }
    //生成地图
    public static int[][] createMap(){
        int arr[][] = new int[15][15];

        for (int i = 0; i < 15; i++) {
            for (int j = 0; j < 15; j++) {
                if (i==0 || j==0 || i==14 || j==14){
                    arr[i][j] = 111;
                }else {
                    arr[i][j] = 0;
                }
            }
        }
        for (int i = 0; i < 10; i++) {
            arr[5][i] = 111;
        }
        for (int i = 14; i >=5 ; i--) {
            arr[10][i] = 111;
        }
        return arr;
    }
    //输出地图
    public static void printMap(int[][] arr){
        for ( int[] temp : arr ) {
            for ( int tem : temp ) {
                System.out.printf("\t"+tem);
            }
            System.out.println();
        }
    }

    /**
     * 使用递归回溯寻找最短路径
     * @param map 地图
     * @param i,j 开始坐标
//     * @param target 终点坐标
     * @return Boolean 是否走通
     * 0 代表没走过    404 代表走不通    222通路表示  111为墙
     * 策略： 下-->右-->上-->左  走不通则回溯
     */
    public static boolean searchPath(int[][] map, int i,int j){
/////////////////////////////
        if (map[12][12]==222){
            System.out.println();
            System.out.println("\t\t\t★☆\\(￣▽￣)/$★  找到出口  ★☆\\(￣▽￣)/$★ ");
            System.out.println();
            printMap(map);
            return true;
        }else {
            if (map[i][j]==0){
                map[i][j]=222;
                if (searchPath(map,i+1,j)){  //下
                    return true;
                }else if(searchPath(map,i,j+1)){    //右
                    return true;
                }else if (searchPath(map,i-1,j)) {  //上
                    return true;
                }else if (searchPath(map,i,j-1)) {  //左
                    return true;
                }else {
                    //走不通
                    map[i][j] = 404;
                    return false;
                }
            }else {
                //不等于0  222走过了   404 走不通    111墙 直接返回
                return false;
            }
        }
    }

}

八皇后问题

问题描述：

• 皇后彼此不能相互攻击，也就是说：任何两个皇后都不能处于同一条横行、纵行或斜线上。

• 回溯

package com.company.recursion;

/**
 * @Function :
 * date 2021/5/15 - 11:39
 * How :
 */
public class Queue {
    //定义一共多少皇后
    int max = 4;
    //定义一个数组 保存皇后放置结果
    int[] arr = new int[max];
    public static void main(String[] args) {
        Queue queue8 = new Queue();
        queue8.pacle(0);
    }
    //编写一个方法 放置皇后
    public void pacle(int n){
        if (n == max){
            System.out.println("完成！");
            this.printQue();
            return;
        }
//        依次放入皇后并检测冲突
        for (int i = 0; i < max; i++) {
            //先把皇后n 放入第一列
            arr[n] = i;
            if (judge(n)){
                pacle(n+1);
            }
        }
    }
    //检测是否与之前的皇后冲突
    /**
     * 每个皇后占一行  循环内数组下标i代表第几个皇后 也就是第几行 其数组的值代表第几列
     * @param n  表示第n个皇后
     * @return
     */
    public  boolean judge( int  n){
        for (int i = 0; i < n; i++) {
            if (arr[i]==arr[n] || Math.abs(n-i)==Math.abs(arr[n]-arr[i])){
                //在同一列上  或者  在同一斜线上
                return false;
            }
        }
        return true;
    }
    public void printQue(){
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("\t"+(arr[i]+1));
        }
        System.out.println();
    }
}