二叉树遍历与对称判断的Java实现解析

1. 二叉树中序遍历的Java实现与实战要点

中序遍历（Inorder Traversal）是二叉树最基本的操作之一，其遍历顺序为"左子树-根节点-右子树"。在Java中实现这一算法，我们通常会采用递归和迭代两种经典方式。

1.1 递归解法代码实现

java复制public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    inorder(root, res);
    return res;
}

private void inorder(TreeNode node, List<Integer> res) {
    if (node == null) return;
    inorder(node.left, res);  // 先遍历左子树
    res.add(node.val);        // 访问根节点
    inorder(node.right, res); // 最后遍历右子树
}

递归实现的优势在于代码简洁直观，完美体现了"分而治之"的算法思想。但需要注意Java的方法调用栈深度限制（通常默认几千层），对于极端不平衡的二叉树可能导致栈溢出。

1.2 迭代解法与栈的应用

java复制public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    Deque<TreeNode> stack = new ArrayDeque<>();
    TreeNode curr = root;
    
    while (curr != null || !stack.isEmpty()) {
        while (curr != null) {    // 将左子树全部入栈
            stack.push(curr);
            curr = curr.left;
        }
        curr = stack.pop();       // 弹出栈顶元素
        res.add(curr.val);        // 访问节点值
        curr = curr.right;        // 转向右子树
    }
    return res;
}

迭代实现通过显式使用栈来模拟递归的隐式调用栈，避免了递归的栈溢出风险。这里有几个关键点需要注意：

1. 内层while循环负责将当前节点的所有左子节点连续入栈
2. 每次弹出栈顶元素后立即访问其值
3. 处理完当前节点后必须转向其右子树

1.3 时间复杂度与空间复杂度分析

两种实现方式的时间复杂度都是O(n)，因为每个节点恰好被访问一次。空间复杂度方面：

• 递归实现：平均O(logn)（平衡树情况），最坏O(n)（链表状树）
• 迭代实现：与递归相同，但实际堆栈使用更可控

提示：在力扣等编程题中，如果遇到二叉树节点值非常大的情况，递归解法可能会因为栈深度问题导致失败，此时迭代解法更为可靠。

2. 对称二叉树的判断方法与实现细节

对称二叉树是指二叉树的镜像与其自身相同，即左右子树互为镜像。这个问题在面试中经常出现，考察对二叉树结构的理解。

2.1 递归判断算法

java复制public boolean isSymmetric(TreeNode root) {
    return root == null || isMirror(root.left, root.right);
}

private boolean isMirror(TreeNode left, TreeNode right) {
    if (left == null && right == null) return true;
    if (left == null || right == null) return false;
    return left.val == right.val 
        && isMirror(left.left, right.right) 
        && isMirror(left.right, right.left);
}

递归解法通过定义辅助函数isMirror来比较两棵子树是否互为镜像。核心逻辑是：

1. 两个节点值必须相等
2. 左子树的左子树与右子树的右子树必须对称
3. 左子树的右子树与右子树的左子树必须对称

2.2 迭代解法实现

java复制public boolean isSymmetric(TreeNode root) {
    if (root == null) return true;
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root.left);
    queue.offer(root.right);
    
    while (!queue.isEmpty()) {
        TreeNode t1 = queue.poll();
        TreeNode t2 = queue.poll();
        if (t1 == null && t2 == null) continue;
        if (t1 == null || t2 == null) return false;
        if (t1.val != t2.val) return false;
        queue.offer(t1.left);
        queue.offer(t2.right);
        queue.offer(t1.right);
        queue.offer(t2.left);
    }
    return true;
}

迭代解法使用队列按特定顺序存储要比较的节点对。每次从队列中取出两个节点比较，然后将它们的子节点按镜像顺序入队。这种方法的空间复杂度最坏情况下是O(n)，但避免了递归的栈溢出风险。

2.3 常见错误与边界情况

在实际编码中，有几个容易出错的地方需要特别注意：

1. 忘记处理root为null的情况
2. 只比较了节点值而忽略了子树结构
3. 迭代实现时节点入队顺序错误
4. 没有正确处理两个节点都为null的情况（应该继续而不是返回true）

3. 二叉树最大深度的计算方法与优化

二叉树的最大深度是指从根节点到最远叶子节点的最长路径上的节点数。这个问题有多种解法，每种都有其特点和适用场景。

3.1 递归深度优先搜索

java复制public int maxDepth(TreeNode root) {
    if (root == null) return 0;
    return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
}

这是最简洁的实现方式，体现了分治思想。算法的时间复杂度为O(n)，空间复杂度为O(h)，其中h是树的高度。

3.2 迭代广度优先搜索

java复制public int maxDepth(TreeNode root) {
    if (root == null) return 0;
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    int depth = 0;
    
    while (!queue.isEmpty()) {
        int size = queue.size();
        for (int i = 0; i < size; i++) {
            TreeNode node = queue.poll();
            if (node.left != null) queue.offer(node.left);
            if (node.right != null) queue.offer(node.right);
        }
        depth++;
    }
    return depth;
}

BFS实现通过队列按层遍历树，每处理完一层深度加1。这种方法虽然代码稍长，但在某些情况下更直观，特别是当需要处理每一层的节点时。

3.3 实际应用中的考量

在实际工程中选择哪种实现方式，需要考虑以下因素：

1. 树的预期高度：对于非常深的树，递归可能导致栈溢出
2. 是否需要层序信息：BFS天然保留了层序信息
3. 代码可读性要求：递归通常更简洁
4. 性能要求：两者时间复杂度相同，但递归的函数调用开销略大

注意：在Java中，递归解法对于深度超过几千的树可能会抛出StackOverflowError。如果预期树可能非常不平衡，应该使用迭代解法。

4. 买卖股票的最佳时机问题解析

虽然这个问题不属于二叉树范畴，但作为力扣经典问题，这里也给出Java实现和分析。我们以最简单的"一次交易"版本为例。

4.1 暴力解法与优化思路

java复制public int maxProfit(int[] prices) {
    int max = 0;
    for (int i = 0; i < prices.length - 1; i++) {
        for (int j = i + 1; j < prices.length; j++) {
            int profit = prices[j] - prices[i];
            if (profit > max) max = profit;
        }
    }
    return max;
}

暴力解法时间复杂度为O(n²)，在力扣上会超时。我们需要更高效的算法。

4.2 一次遍历最优解

java复制public int maxProfit(int[] prices) {
    int minPrice = Integer.MAX_VALUE;
    int maxProfit = 0;
    for (int price : prices) {
        if (price < minPrice) {
            minPrice = price;
        } else if (price - minPrice > maxProfit) {
            maxProfit = price - minPrice;
        }
    }
    return maxProfit;
}

这个算法只需要一次遍历，时间复杂度O(n)，空间复杂度O(1)。其核心思想是：

1. 记录遍历过的最低价格
2. 计算当前价格与最低价格的差值
3. 更新最大利润

4.3 算法正确性证明

该算法的正确性基于以下观察：

• 最大利润必然是在某个价格卖出，而这个价格之前必然有最低的买入价格
• 我们只需要在遍历时记住之前的最低价格，就能计算出当前卖出的最大可能利润
• 通过不断更新最低价格和最大利润，最终可以得到全局最优解

对于更复杂的股票买卖问题（如多次交易、含冷冻期等），可以基于类似的思路进行扩展，通常需要用到动态规划技术。