栈溢出及解决

栈溢出的原因

1. 递归深度过大：递归调用次数太多，每次调用都会在栈上分配内存。
2. 每个递归调用占用的栈空间过多：如果函数有很多局部变量或者大的局部数组，每次递归调用都会占用更多的栈空间。
3. 系统栈空间有限：操作系统对每个线程分配的栈空间是有限的，通常在几百KB到几MB之间。

例子：深度非常大的二叉树

考虑一个极端的二叉树，例如一个单链的二叉树（即每个节点只有一个子节点），这样的树的深度等于节点数。如果节点数非常大，递归计算深度时会导致栈溢出。

示例代码：

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

public class MaxDepthOfBinaryTree {

    // 计算二叉树的最大深度
    public static int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftDepth = maxDepth(root.left);
        int rightDepth = maxDepth(root.right);
        return Math.max(leftDepth, rightDepth) + 1;
    }

    public static void main(String[] args) {
        // 创建一个非常深的单链二叉树
        TreeNode root = new TreeNode(0);
        TreeNode current = root;
        for (int i = 1; i < 100000; i++) {
            current.right = new TreeNode(i);
            current = current.right;
        }

        // 计算并输出二叉树的最大深度
        // 这可能会导致栈溢出
        int depth = maxDepth(root);
        System.out.println("二叉树的最大深度是: " + depth);
    }
}

解决栈溢出的方法

1. 改用迭代法：对于深度优先搜索（DFS），可以使用显式栈来代替递归栈。

import java.util.Stack;

public class MaxDepthOfBinaryTree {

    // 使用迭代方法计算二叉树的最大深度
    public static int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }

        Stack<TreeNode> stack = new Stack<>();
        Stack<Integer> depths = new Stack<>();
        stack.push(root);
        depths.push(1);

        int maxDepth = 0;
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            int currentDepth = depths.pop();
            if (node != null) {
                maxDepth = Math.max(maxDepth, currentDepth);
                stack.push(node.left);
                stack.push(node.right);
                depths.push(currentDepth + 1);
                depths.push(currentDepth + 1);
            }
        }
        return maxDepth;
    }

    public static void main(String[] args) {
        // 创建一个非常深的单链二叉树
        TreeNode root = new TreeNode(0);
        TreeNode current = root;
        for (int i = 1; i < 100000; i++) {
            current.right = new TreeNode(i);
            current = current.right;
        }

        // 计算并输出二叉树的最大深度
        // 使用迭代方法，不会导致栈溢出
        int depth = maxDepth(root);
        System.out.println("二叉树的最大深度是: " + depth);
    }
}

 

   2. 增加栈大小：在某些编程环境中，可以增加栈的大小以允许更深的递归（不推荐，治标不治本）。

   3. 优化递归算法：通过尾递归优化等手段来减少栈空间的使用（Java不支持真正的尾递归优化）。