Java解決遞迴造成的堆疊溢位問題

TechSynapse發表於2024-08-13
Java遞迴

在Java中，遞迴造成的堆疊溢位問題通常是因為遞迴呼叫的深度過大，導致呼叫棧空間不足。解決這類問題的一種常見方法是使用非遞迴的方式重寫演算法，即使用迭代替代遞迴。

1.方法一：非遞迴的方式重寫演算法（迭代替代遞迴）

下面透過一個典型的遞迴例子——計算斐波那契數列的第n項，來演示如何用迭代的方式避免堆疊溢位。

1.1遞迴版本的斐波那契數列

遞迴版本的斐波那契數列實現很簡單，但是效率較低，尤其是對於大的n值，很容易造成堆疊溢位。

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));  
    }  
}

1.2迭代版本的斐波那契數列

迭代版本的斐波那契數列避免了遞迴呼叫，因此不會造成堆疊溢位。

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));  
    }  
}

在迭代版本中，我們使用了兩個變數a和b來儲存斐波那契數列中的連續兩個數，透過迴圈來計算第n項的值。這種方法避免了遞迴呼叫，因此不會造成堆疊溢位，即使n的值很大。

1.3小結

透過迭代替代遞迴是解決遞迴造成的堆疊溢位問題的常用方法。在實際開發中，如果遞迴深度可能非常大，建議首先考慮使用迭代的方式來實現演算法。

2.方法二：尾遞迴最佳化

尾遞迴是一種特殊的遞迴形式，遞迴呼叫是函式的最後一個操作。在支援尾遞迴最佳化的程式語言中（如Scala、Kotlin的某些情況下，以及透過編譯器最佳化或特定設定的Java），尾遞迴可以被編譯器最佳化成迭代形式，從而避免堆疊溢位。

然而，標準的Java編譯器並不自動進行尾遞迴最佳化。但是，我們可以手動將遞迴函式改寫為尾遞迴形式，並使用迴圈來模擬遞迴呼叫棧。

以下是一個尾遞迴最佳化的斐波那契數列示例，但請注意，Java標準編譯器不會最佳化此程式碼，所以這裡只是展示尾遞迴的形式。實際上，要避免Java中的堆疊溢位，還是需要手動將其改寫為迭代形式或使用其他技術。

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));  
    }  
}

實際上，在Java中避免堆疊溢位的正確方法是使用迭代，如之前所示。

3.方法三：使用自定義的棧結構

另一種方法是使用自定義的棧結構來模擬遞迴過程。這種方法允許你控制棧的大小，並在需要時增加棧空間。然而，這通常比簡單的迭代更復雜，且不太常用。

以下是一個使用自定義棧來計算斐波那契數列的示例：

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));  
    }  
}

在這個示例中，我們使用了一個棧來模擬遞迴過程。每個Pair物件都儲存了一個n值和一個對應的斐波那契數值（如果已計算的話）。我們透過將較小的n值壓入棧中來模擬遞迴呼叫，並在需要時從棧中取出它們來計算對應的斐波那契數值。這種方法允許我們控制棧的使用，並避免了遞迴造成的堆疊溢位問題。

相關文章