Java递归造成的堆栈溢出问题及解决方案

public class FibonacciRecursive {  
    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) {  
        int n = 40; // 尝试较大的数，比如40，可能会导致堆栈溢出  
        System.out.println("Fibonacci(" + n + ") = " + fibonacci(n));  
    }  
}

public class FibonacciIterative {  
    public static int fibonacci(int n) {  
        if (n <= 1) {  
            return n;  
        }  
        int a = 0, b = 1;  
        for (int i = 2; i <= n; i++) {  
            int temp = a + b;  
            a = b;  
            b = temp;  
        }  
        return b;  
    }  
    public static void main(String[] args) {  
        int n = 90; // 即使n很大，也不会导致堆栈溢出  
        System.out.println("Fibonacci(" + n + ") = " + fibonacci(n));  
    }  
}

public class FibonacciTailRecursive {  
    public static int fibonacci(int n, int a, int b) {  
        if (n == 0) return a;  
        if (n == 1) return b;  
        return fibonacci(n - 1, b, a + b); // 尾递归调用  
    }  
    public static void main(String[] args) {  
        int n = 40; // 在标准Java中，这仍然可能导致堆栈溢出  
        System.out.println("Fibonacci(" + n + ") = " + fibonacci(n, 0, 1));  
    }  
}

import java.util.Stack;  
public class FibonacciWithStack {  
    static class Pair {  
        int n;  
        int value; // 用于存储已计算的值，以避免重复计算  
        Pair(int n, int value) {  
            this.n = n;  
            this.value = value;  
        }  
    }  
    public static int fibonacci(int n) {  
        Stack<Pair> stack = new Stack<>();  
        stack.push(new Pair(n, -1)); // -1 表示值尚未计算  
        while (!stack.isEmpty()) {  
            Pair pair = stack.pop();  
            int currentN = pair.n;  
            int currentValue = pair.value;  
            if (currentValue != -1) {  
                // 如果值已经计算过，则直接使用  
                continue;  
            }  
            if (currentN <= 1) {  
                // 基本情况  
                currentValue = currentN;  
            } else {  
                // 递归情况，将更小的n值压入栈中  
                stack.push(new Pair(currentN - 1, -1));  
                stack.push(new Pair(currentN - 2, -1));  
            }  
            // 存储计算过的值，以便后续使用  
            stack.push(new Pair(currentN, currentValue));  
        }  
        // 栈底元素存储了最终结果  
        return stack.peek().value;  
    }  
    public static void main(String[] args) {  
        int n = 40;  
        System.out.println("Fibonacci(" + n + ") = " + fibonacci(n));  
    }  
}