java数据结构与算法学习_递归

递归

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

递归调用规则

1.当程序执行到一个方法时，就会开辟一个独立的空间（栈帧）
2.递归调用时，遇到递归方法就会开辟一个栈帧，每个栈帧的局部变量，都是独立的。
3.当最后一次调用递归方法完毕后，开始按顺序退出栈帧
4.最后回到main方法栈帧，程序执行完毕over！

解决问题：

8皇后，汉诺塔，阶乘问题，迷宫问题，球和篮子的问题

递归遵守重要规则

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

迷宫问题

问题描述，现在有一个迷宫，以二维数组表示，需要小球通过某种策略找到出口

1代表墙，小球不能通过，起点为1，1，终点为6，5

    //先创建一个二维数组，模拟迷宫
    //地图
    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();
    }

用递归解决该问题
0代表没有走过，1代表墙，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-1,j-1)){ //向左走
          return true;
        }else{ //上下左右都走不通，说明该点走不通
          map[i][j] = 3;
          return false;
        }
      }
      else{ //如果不等于0，map可能为1，2，3
        return false;
      }
    }
  }

结果显示

八皇后问题

问题描述：在一个棋盘上放8个皇后，皇后不能互相攻击（不能在同一横一竖一斜线上）

public class Queue8 {

  //定义一个max表示共有多少个皇后
  int max = 8;
  //定义数组array，保存皇后放置位置的结果
  //arr[8] = {0,4,7,5,2,6,1,3}
  //arr[i(0)]0 = 第一行，第一个（i+1,0+1）
  //arr[i(1)]4 = 第二行，第5个（i+1,4+1）
  int[] array = new int[max];
  public static void main(String[] args) {
    Queue8 queue8 = new Queue8();
    queue8.check(0);
  }

  //放置第n个皇后
  //check是每一次递归时，进入到check方法中，都有一套for循环，因此会有回溯
  private void check(int n){
    if(n == max){
      print();
      return;
    }
    //依次放入皇后，并判断是否冲突
    for(int i = 0 ; i < max ; i++){
      //先把当前这个皇后n ，放到该行的第1列
      array[n] = i;
      //判断当前放置第n个皇后到i列时，是否冲突
      if(judge(n)){
        //如果不冲突，就放n+1个皇后，开始递归
        check(n+1);
      }
      //如果冲突，就继续执行array[n] = i ;即将第n个皇后，放置在本行的后移的一个位置
    }
  }

  //查看当我们放置第n个皇后，就去检测该皇后是否和前面已经摆放的皇后冲突
  /**
   *
   * @param n 表示第n个皇后
   * @return
   */
  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(){
    for(int i = 0 ; i < array.length ; i++){
      System.out.print(array[i] + " ");
    }
    System.out.println();
  }
}

结果显示：共有92种解法