用java代码详解递归算法

递归 是一种编程技巧，指的是函数（或方法）直接或间接地调用自身。通过将一个大问题分解成一个或多个相似的、规模更小的子问题来解决。递归通常包含两个关键部分：

1. 基线条件（Base Case）：确定递归何时终止，防止无限循环。
2. 递归步骤（Recursive Step）：将问题分解成更小的子问题，并调用自身来解决。

递归的常见用法

递归常用于以下场景：

• 数学计算：如阶乘、斐波那契数列。
• 数据结构操作：如遍历树（二叉树、多叉树）、链表、图。
• 分治算法：如归并排序、快速排序。
• 回溯算法：如八皇后问题、迷宫求解。

Java代码示例

1. 计算阶乘（n!）

阶乘的定义：

• n! = n × (n-1) × (n-2) × ... × 1
• 0! = 1（基线条件）

public class RecursionExample {
    public static int factorial(int n) {
        // 基线条件：0! = 1
        if (n == 0) {
            return 1;
        }
        // 递归步骤：n! = n * (n-1)!
        return n * factorial(n - 1);
    }

    public static void main(String[] args) {
        int n = 5;
        System.out.println(n + "! = " + factorial(n)); // 输出：5! = 120
    }
}

2. 斐波那契数列

定义：

• Fib(0) = 0
• Fib(1) = 1
• Fib(n) = Fib(n-1) + Fib(n-2)（n ≥ 2）

public class Fibonacci {
    public static int fibonacci(int n) {
        // 基线条件
        if (n == 0) return 0;
        if (n == 1) return 1;
        
        // 递归步骤
        return fibonacci(n - 1) + fibonacci(n - 2);
    }

    public static void main(String[] args) {
        int n = 6;
        System.out.println("Fib(" + n + ") = " + fibonacci(n)); // 输出：Fib(6) = 8
    }
}

3. 遍历二叉树（前序遍历）

假设有一个简单的二叉树节点类：

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

public class TreeTraversal {
    // 递归前序遍历：根 -> 左 -> 右
    public static void preOrder(TreeNode node) {
        if (node == null) return; // 基线条件
        System.out.print(node.val + " "); // 访问根节点
        preOrder(node.left);              // 遍历左子树
        preOrder(node.right);             // 遍历右子树
    }

    public static void main(String[] args) {
        // 构建一个简单的二叉树：
        //       1
        //      / \
        //     2   3
        //    / \
        //   4   5
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);

        preOrder(root); // 输出：1 2 4 5 3
    }
}

递归的优缺点

优点：

• 代码简洁，容易理解（对于符合递归思维的问题）。
• 适合处理递归定义的数据结构（如树、链表）。

缺点：

• 可能产生大量的函数调用，导致栈溢出（StackOverflowError）。
• 效率可能较低（如斐波那契数列的递归实现有大量重复计算）。

改进方法：
对于效率问题，通常可以用记忆化（Memoization） 或迭代来优化。例如，斐波那契数列可以用动态规划避免重复计算。