Implementación Java del algoritmo recursivo (secuencia de Fibonacci, Torre de Hanoi, problema de N queen)

Definición recursiva

En matemáticas e informática, la recursividad se refiere al método de utilizar la función en sí en la definición de una función.

Tres elementos de recursividad

1. Aclarar las condiciones de terminación recursiva;

2. Indique el método de procesamiento cuando termine la recursividad;

3. Extraiga la lógica repetitiva y reduzca la escala del problema.

secuencia Fibonacci

La secuencia de Fibonacci (secuencia de Fibonacci), también conocida como la secuencia de la sección áurea, se introdujo debido a que el matemático Leonardoda Fibonacci (Leonardoda Fibonacci) tomó la reproducción del conejo como ejemplo, por lo que también se le llama la "Secuencia del conejo", refiriéndose a Is a secuencia de números: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ... En matemáticas, la secuencia de Fibonacci se define mediante un método recursivo de la siguiente manera: F (0) = 0, F (1) = 1, F (n) = F (n-1) + F (n-2) (n ≥ 2, n ∈ N *)

implementación de código java

package 递归算法;

public class Fibonacci {
    
    
    public static void main(String[] args) {
    
    
        System.out.println(fib(7));
    }

    /**
     * 
     * @param i 第i个元素
     * @return 返回第i个元素的值
     */
    private static int fib(int i) {
    
    
        if (i == 0 || i == 1){
    
    
            // 终止条件
            return i;
        }
        // 递归条件
        return fib(i - 1) + fib(i - 2);
    }
}

Torre de Hanoi

Según la leyenda, había un juego llamado Hanoi en el antiguo templo indio. El juego está en un dispositivo de placa de cobre con tres varillas (numeradas A, B, C). En la varilla A, se colocan 64 placas de oro en orden de abajo hacia arriba, de grande a pequeña (como se muestra en la figura siguiente). El objetivo del juego: mover todos los discos de oro del polo A al polo C y apilarlos en el orden original. Reglas de funcionamiento: Solo se puede mover una placa a la vez, y las tres barras mantienen siempre la placa grande hacia abajo y la placa pequeña hacia arriba durante el movimiento. La placa puede colocarse en cualquiera de las barras A, B y C durante el operación.

implementación de código java

package 递归算法;

public class Hanoi {
    
    
    public static void main(String[] args) {
    
    
        hanoi(3, "A", "B", "C");
    }

    /**
     *
     * @param i 层数
     * @param a 初始盘
     * @param b 借助盘
     * @param c 目标盘
     */
    private static void hanoi(int i, String a, String b, String c) {
    
    
        // 终止条件
        if (i == 1){
    
    
            move(1, a, c);
        }
        else{
    
    
            hanoi(i-1, a, c, b);
            move(i, a, c);
            hanoi(i-1, b, a, c);
        }
    }

    /**
     *
     * @param i 层数
     * @param a 初始盘
     * @param b 目标盘
     */
    private static void move(int i, String a, String b) {
    
    
        System.out.println(a + "-->" + b);
    }
}

N problema de la reina

El problema de las n reinas estudia cómo colocar n reinas en un tablero de ajedrez de n × n y hacer que las reinas no puedan atacarse entre sí.

implementación de código java

package 递归算法;

import java.util.Scanner;

// 八皇后问题
public class NQueens {
    
    
    // 皇后个数
    private static int queen;
    // 计数
    private static int count = 0;
    // 定义一个棋盘
    static int[][] map;

    // 构造方法
    public NQueens(int queen){
    
    
        // 初始化皇后
        NQueens.queen = queen;
        // 初始化棋盘
        map = new int[queen][queen];
    }

    /**
     * 八皇后算法
     * @param row 表示行
     */
    public void play(int row){
    
    

        // 遍历当前行的所有单元格
        for(int i = 0; i < queen; i++){
    
    
            if (check(row, i)){
    
    
                map[row][i] = 1;
                if (row == queen-1){
    
    
                    show();
                } else {
    
    
                    play(row+1);
                }

                // 清空棋盘
                map[row][i] = 0;
            }
        }
    }

    /**
     * 显示棋盘的方法
     */
    public void show(){
    
    
        count++;
        System.out.println("第" + count + "种排列方式");
            for(int i = 0; i < queen; i++){
    
    
                for(int j = 0; j < queen; j++){
    
    
                    System.out.print(map[i][j] + " ");
                }
                System.out.println();
        }

    }

    /**
     * 检查是否可以放皇后
     * @param row 行
     * @param col 列
     * @return false不可以， true可以
     */
    private boolean check(int row, int col) {
    
    
        // 判断上面是否有皇后
        for(int i = row - 1; i >= 0; i--){
    
    
            if (map[i][col] == 1){
    
    
                return false;
            }
        }

        // 判左断斜上方是否有皇后
        for(int i = row -1, j = col - 1; i >= 0 && j >=0; i--, j--){
    
    
            if (map[i][j] == 1){
    
    
                return false;
            }
        }

        // 判断右斜上方是否后皇后
        for(int i = row -1, j = col + 1; i >= 0 && j < queen; i--, j++){
    
    
            if (map[i][j] == 1) {
    
    
                return false;
            }
        }
        return true;
    }



    public static void main(String[] args) {
    
    
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入皇后个数：");
        int queen = scanner.nextInt();
        NQueens queens = new NQueens(queen);
        queens.play(0);
    }

}