编程思维训练：Java递归算法的典型问题

原创刺骨的言语ヽ痛彻心扉 2024-09-26 00:30 39阅读 0赞

在Java中，递归算法是一种解决问题的方法，通过将大问题分解为更小的相同问题来重复这个过程。以下在编程思维训练中常见的Java递归问题：

1. **斐波那契数列**：计算一个数是否是斐波那契数列中的项。

```java
public static boolean isFibonacci(int n) {
    // 0和1是斐波那契数列的前两个项
    if (n <= 1) {
        return true;
    }

// 斐波那契递归公式：f(n) = f(n-1) + f(n-2)
    int fibBefore = isFibonacci(n - 1);
    int fibAfter = isFibonacci(n - 2);

// 如果n-1是斐波那契数列的项，那么n也是
    return fibBefore && fibAfter;
}
```

2. **二叉树遍历**：递归地遍历二叉树（前序、中序或后序）。

```java
// 前序遍历
public static void preorderTraversal(TreeNode root) {
    if (root == null) return;

// 递归访问根节点，然后遍历左子树
    System.out.print(root.val + " "); // 输出节点值
    preorderTraversal(root.left);
}

// 中序遍历
public static void inorderTraversal(TreeNode root) {
    if (root == null) return;

inorderTraversal(root.left);
    System.out.print(root.val + " "); // 输出节点值
    inorderTraversal(root.right);
}
```

3. **矩阵旋转**：根据90度、180度或270度的不同旋转需求，递归地处理矩阵元素。

```java
public class MatrixRotation {
    public void rotateMatrix(int[][] matrix, int k) {
        // 90度逆时针旋转
        if (k == 90 || k == -90) {
            reverse(matrix);
            transpose(matrix);
            reverse(matrix);
        }
        
        // 遍历矩阵，递归地处理子矩阵
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                rotateMatrixElement(matrix, i, j, k);
            }
        }
    }

// 子矩阵旋转元素的递归函数
    private void rotateMatrixElement(int[][] matrix, int row, int col, int k) {
        if (k == 90 || k == -90) {
            // 对于90度或-90度的旋转，交换行和列的索引
            int tempRow = row;
            int tempCol = col;

row = tempRow;
            col = tempCol;
        }

// 按照旋转角度调整矩阵元素的位置
        if (k == 90) {
            // 90度逆时针旋转
            matrix[row][col] = matrix[row][matrix[row].length - col - 1];
        } else if (k == -90) {
            // -90度顺时针旋转
            matrix[row][col] = matrix[matrix[row].length - col - 1][row];
        }

// 递归处理子矩阵
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                rotateMatrixElement(matrix, i, j, k);
            }
        }
    }

// 反转矩阵
    private void reverse(int[][] matrix) {
        for (int i = 0; i < matrix.length / 2; i++) {
            int temp = matrix[i][matrix.length - 1 - i]].val;
            matrix[i][matrix.length - 1 - i]] = matrix[matrix.length - 1 - i][i]].val;
            matrix[matrix.length - 1 - i][i]].val = temp;
        }
    }

// 矩阵转置
    private void transpose(int[][] matrix) {
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                int tempRow = i;
                int tempCol = j;

matrix[tempRow][tempCol]] = matrix[i][j];
            }
        }
    }
}
```

以上问题主要围绕递归思维进行，对于理解算法逻辑、解决复杂问题非常有帮助。