java之函数的递归

递归定义：递归是指一个方法直接或间接调用自身的过程。

递归的一般格式：

public static Object methodName(Object parameters) {
        // 终止条件
        if (条件) {
            return 默认值;
        }
        // 递归调用
        Object result = methodName(parameters);
        // 处理递归结果
        return result;
    }

1、阶乘计算（最经典的递归示例）

public class Factorial {
    public static int factorial(int n) {
        if (n == 0 || n == 1) {  // 基本情况
            return 1;
        } else {                  // 递归情况
            return n * factorial(n - 1);
        }
    }

    public static void main(String[] args) {
        System.out.println("5的阶乘是: " + factorial(5));  // 输出120
    }
}

2、斐波那契数列

public class Fibonacci {
    public static int fibonacci(int n) {
        if (n <= 1) {             // 基本情况
            return n;
        } else {                  // 递归情况
            return fibonacci(n - 1) + fibonacci(n - 2);
        }
    }

    public static void main(String[] args) {
        System.out.println("第6个斐波那契数是: " + fibonacci(6));  // 输出8
    }
}

3、数字各位相加

public class SumDigits {
    public static int sumDigits(int num) {
        if (num < 10) {           // 基本情况
            return num;
        } else {                  // 递归情况
            return num % 10 + sumDigits(num / 10);
        }
    }

    public static void main(String[] args) {
        System.out.println("1234各位数字之和是: " + sumDigits(1234));  // 输出10
    }
}

4、倒序打印字符串

public class ReversePrint {
    public static void reversePrint(String str) {
        if (str.length() <= 1) {  // 基本情况
            System.out.print(str);
        } else {                 // 递归情况
            System.out.print(str.charAt(str.length() - 1));
            reversePrint(str.substring(0, str.length() - 1));
        }
    }

    public static void main(String[] args) {
        System.out.print("'hello'倒序输出: ");
        reversePrint("hello");  // 输出olleh
    }
}

以数字相加为例：sumDigits(1234)

分析递归执行的流程

执行流程分析：

1. 初始调用：sumDigits(1234)

   • 1234 ≥ 10 → 进入 else 分支

   • 计算：1234 % 10 + sumDigits(1234 / 10)

   • → 4 + sumDigits(123)

2. 递归调用 1：sumDigits(123)

   • 123 ≥ 10 → 进入 else 分支

   • 计算：123 % 10 + sumDigits(123 / 10)

   • → 3 + sumDigits(12)

3. 递归调用 2：sumDigits(12)

   • 12 ≥ 10 → 进入 else 分支

   • 计算：12 % 10 + sumDigits(12 / 10)

   • → 2 + sumDigits(1)

4. 递归调用 3：sumDigits(1)

   • 1 < 10 → 触发基本情况

   • 直接返回 1

递归返回过程：

1. sumDigits(1) 返回 1 给 sumDigits(12)

   • 2 + sumDigits(1) → 2 + 1 = 3

2. sumDigits(12) 返回 3 给 sumDigits(123)

   • 3 + sumDigits(12) → 3 + 3 = 6

3. sumDigits(123) 返回 6 给 sumDigits(1234)

   • 4 + sumDigits(123) → 4 + 6 = 10

4. 最终 sumDigits(1234) 返回 10

可视化结果：

sumDigits(1234)
= 4 + sumDigits(123)
= 4 + (3 + sumDigits(12))
= 4 + (3 + (2 + sumDigits(1)))
= 4 + (3 + (2 + 1)))  // 触发基本情况
= 4 + (3 + 3)
= 4 + 6
= 10