二叉树遍历与经典问题解析：从基础到实战

1. 二叉树基础与遍历方法精讲

1.1 二叉树数据结构解析

二叉树是每个节点最多有两个子节点的树结构，通常称为左子节点和右子节点。在算法面试和实际应用中，二叉树是最基础也是最重要的数据结构之一。理解二叉树的各种遍历方式及其应用场景，是解决更复杂树形结构问题的基石。

二叉树的节点通常定义为：

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

1.2 深度优先遍历（DFS）详解

1.2.1 前序遍历（Pre-order）

前序遍历的顺序是：根节点 → 左子树 → 右子树。这种遍历方式常用于树的复制、序列化等场景。

递归实现：

java复制void preOrder(TreeNode root, List<Integer> result) {
    if (root == null) return;
    result.add(root.val);  // 先访问根节点
    preOrder(root.left, result);  // 再遍历左子树
    preOrder(root.right, result); // 最后遍历右子树
}

迭代实现（使用栈）：

java复制List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    if (root == null) return result;
    
    Deque<TreeNode> stack = new LinkedList<>();
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        result.add(node.val);
        // 注意先压右节点，再压左节点
        if (node.right != null) stack.push(node.right);
        if (node.left != null) stack.push(node.left);
    }
    return result;
}

1.2.2 中序遍历（In-order）

中序遍历的顺序是：左子树 → 根节点 → 右子树。二叉搜索树的中序遍历结果是有序的。

递归实现：

java复制void inOrder(TreeNode root, List<Integer> result) {
    if (root == null) return;
    inOrder(root.left, result);  // 先遍历左子树
    result.add(root.val);        // 再访问根节点
    inOrder(root.right, result); // 最后遍历右子树
}

迭代实现：

java复制List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    Deque<TreeNode> stack = new LinkedList<>();
    TreeNode curr = root;
    
    while (curr != null || !stack.isEmpty()) {
        // 先到达最左节点
        while (curr != null) {
            stack.push(curr);
            curr = curr.left;
        }
        curr = stack.pop();
        result.add(curr.val);
        curr = curr.right; // 转向右子树
    }
    return result;
}

1.2.3 后序遍历（Post-order）

后序遍历的顺序是：左子树 → 右子树 → 根节点。常用于树的删除、表达式求值等场景。

递归实现：

java复制void postOrder(TreeNode root, List<Integer> result) {
    if (root == null) return;
    postOrder(root.left, result);  // 先遍历左子树
    postOrder(root.right, result); // 再遍历右子树
    result.add(root.val);          // 最后访问根节点
}

迭代实现（反转前序）：

java复制List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    if (root == null) return result;
    
    Deque<TreeNode> stack = new LinkedList<>();
    stack.push(root);
    while (!sta