In Java, stack overflow problems caused by recursion are usually due to recursive calls that are too deep, resulting in insufficient space on the call stack. A common approach to solving this type of problem is to rewrite the algorithm in a non-recursive way, i.e., using iteration instead of recursion.
1. Method 1: Rewrite the algorithm in a non-recursive way (iteration instead of recursion)
Here's a typical recursive example - computing the nth term of the Fibonacci series - to demonstrate how to avoid stack overflow with iteration.
1.1 Recursive version of the Fibonacci series
The recursive version of the Fibonacci series is simple to implement, but is less efficient, especially for large values of n, and can easily cause stack overflow.
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; // attempt，for example40，May cause a stack overflow
("Fibonacci(" + n + ") = " + fibonacci(n));
}
}
1.2 Iterated version of the Fibonacci series
The iterative version of the Fibonacci sequence avoids recursive calls and therefore does not cause a stack overflow.
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; // even ifnmajor，It also doesn't cause a stack overflow
("Fibonacci(" + n + ") = " + fibonacci(n));
}
}
In the iterative version, we use two variablesacap (a poem)bto hold two consecutive numbers in the Fibonacci series and calculate the value of the nth term by looping through them. This method avoids recursive calls and therefore does not cause a stack overflow, even if the value of n is large.
1.3 Summary
Replacing recursion by iteration is a common solution to the stack overflow problem caused by recursion. In practice, if the recursion depth may be very large, it is recommended to first consider using iteration to implement the algorithm.
2. Method 2: Tail Recursive Optimization
Tail recursion is a special form of recursion where the recursive call is the last operation of a function. In programming languages that support tail recursion optimization (e.g., Scala, Kotlin in some cases, and Java through compiler optimization or specific setups), tail recursion can be optimized by the compiler to be in iterative form, thus avoiding stack overflow.
However, the standard Java compiler does not automatically perform tail-recursive optimization. However, we can manually rewrite recursive functions in tail-recursive form and use loops to simulate a recursive call stack.
Below is an example of a tail-recursive optimized Fibonacci series, but note that the Java standard compiler does not optimize this code, so only the tail-recursive form is shown here. In fact, to avoid stack overflows in Java, you still need to manually rewrite it into iterative form or use other techniques.
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); // tail recursive call
}
public static void main(String[] args) {
int n = 40; // standardizedJavacenter，This can still result in a stack overflow
("Fibonacci(" + n + ") = " + fibonacci(n, 0, 1));
}
}
In fact, the correct way to avoid stack overflow in Java is to use iteration, as shown previously.
3. Method 3: Use a customized stack structure
Another approach is to use a custom stack structure to simulate the recursive process. This approach allows you to control the size of the stack and add stack space when needed. However, this is usually more complex than simple iteration and is less commonly used.
Below is an example of using a custom stack to compute a Fibonacci series:
import ;
public class FibonacciWithStack {
static class Pair {
int n; int value; // Used to store calculated values to avoid double counting.
int value; // used to store calculated values to avoid double counting
Pair(int n, int value) {
= n; = value; // Use to store computed values to avoid double counting.
= value; }
}
}
public static int fibonacci(int n) {
Stack<Pair> stack = new Stack<> ();
(new Pair(n, -1)); // -1 means the value has not been computed yet
while (! ()) {
Pair pair = (); int currentN = ;; // Pair(n, -1); stack = new Stack(n, -1)
int currentN = ;
int currentValue = ;
if (currentValue ! = -1) {
// If the value has already been computed, use the
continue; }
}
if (currentN <= 1) {
// Base case
currentValue = currentN; } else { if (currentN <= 1)
} else {
// Recursive case, pressing smaller n values onto the stack
(new Pair(currentN - 1, -1)).
(new Pair(currentN - 2, -1));
}
// Store the computed value for subsequent use
(new Pair(currentN, currentValue)); }
}
// The bottom element of the stack stores the final result
return ().value; }
}
public static void main(String[] args) {
int n = 40; ("Fibonacci(" + n + ") = " + fibonacci(" + "))
("Fibonacci(" + n + ") = " + fibonacci(n)); }
}
}
In this example, we use a stack to model the recursive process. EachPairobjects all store anvalue and a corresponding Fibonacci value (if one has been computed). We do this by combining the smallernvalues into the stack to simulate recursive calls and remove them from the stack when needed to compute the corresponding Fibonacci values. This approach allows us to control the use of the stack and avoids the stack overflow problem caused by recursion.