LeetCode 106.Construct Binary Tree from Inorder and Postorder Traversal(用中序与后序遍历构造一棵二叉树) 解题分析

博客围绕LeetCode题目,给出一棵二叉树的中序和后序遍历数组,要求还原该二叉树。介绍了中序和后序遍历数组的结构特点,提出解题思路,即利用后序遍历数组最后元素确定根结点,划分左右子树数组,将问题转化为递归问题,并提及递归终止条件。

题目来源

https://leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/

题目描述

Given inorder and postorder traversal of a tree, construct the binary tree.

Note:

You may assume that duplicates do not exist in the tree.

For example, given

inorder = [9,3,15,20,7]
postorder = [9,15,7,20,3]

Return the following binary tree:

在这里插入图片描述

题意分析

给出一棵二叉树的中序遍历数组和后序遍历数组,还原这课二叉树。

前序知识

相信能看到这篇博客的你们一定已经知道二叉树、中序遍历和后序遍历(当然还有先序遍历)是什么。

假设我们有如下一棵二叉树:
在这里插入图片描述

它的中序遍历数组数是 [4,2,5,1,6,3,7],它的后序遍历数组数是 [4,5,2,6,7,3,1]

经过观察,我们应该能发现:

  1. 中序遍历数组的根结点元素“1”的左边的数组([4,2,5])是根结点左子树的中序遍历数组,右边的数组([6,3,7])是根结点右子树的中序遍历数组。
  2. 后序遍历数组的最后那个元素是根结点元素“1”,左子树数组是除最后一个元素(根结点)外靠前的部分([4,5,2]),右子树数组是靠后的那部分([6,7,3])。

于是我们可以总结:

  1. 中序遍历数组的结构是:若一个数组表示一个二叉树,那么数组中有一个元素是根结点,在根节点的左边的数组是左子树数组,在根结点右边的数组是右子树数组。这个根结点元素在哪?需要有额外信息确定,比如后序遍历数组的最后一个元素(或者先序遍历的第一个元素)。
  2. 后序遍历数组的结构是:若一个数组表示一棵二叉树,那么最后一个元素是根结点,左子树数组是除最后一个元素(根结点)外靠前的部分,右子树数组是靠后的那部分。

题目思路

所以本题的思路可以是:用后序遍历数组的最后一个元素确定二叉树的根结点元素root_val,然后使用这个元素找到它在中序遍历数组的位置inindex,(中序遍历数组下标从instartinend)从而确定左右子树的中序遍历数组;同时利用左右子树中序遍历数组的长度确定左右子树后序遍历数组,最后将问题划分成“找左右子数组的根结点”的递归问题。

加粗部分要怎么做呢?右子树长度是inend-inindex,那么后序遍历数组(后序遍历数组最后一个元素的下标是postend)的右子树的最后一个元素的下标是postend-1,左子树的最后一个元素下标是postend-1-(inend-instart)

对于后序遍历数组,我们这需要知道它的结束部分postend。因为结束部分是它所在子树数组的根结点,而它的poststart并没有什么卵用。

做递归还需要有终止条件,认为instart>inend就是终止条件。

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        return helper(inorder, postorder, 0, inorder.size()-1, postorder.size()-1);
    }
    TreeNode* helper(vector<int> &inorder, vector<int> &postorder, int instart, int inend, int postend) {
        if(instart>inend) {  //终止条件
            return NULL;
        }
        int root_val = postorder[postend];  //从后序遍历数组的最后一个元素获得当前树的根结点
        int inindex;
        for(int i=instart; i<=inend; i++) {  //相应得到中序遍历数组中根结点位置
            if(root_val == inorder[i]) {
                inindex = i;
            }
        }
        TreeNode* right = helper(inorder, postorder, inindex+1, inend, postend-1);  // 构建右子树
        TreeNode* left = helper(inorder, postorder, instart, inindex-1, postend-1-(inend-inindex));  // 构建左子树
        TreeNode* root = new TreeNode(root_val);
        root->left = left;
        root->right = right;
        return root; //返回构建好的树
    }
};

你的赞或关注都是对博主莫大的激励!

<think>嗯,用户想了解如何用代码实现二叉树的前、中后序遍历算法,还提到了示例。首先,我得回忆一下这三种遍历的基本概念和它们的顺区别。前遍历是根-左-右,中是左-根-右,后序是左-右-根。对吧? 接下来,用户可能需要具体的代码示例,所以得考虑用哪种编程语言。根据提供的引用,特别是引用3,里面提到了C++的递归实现,但用户可能对Python更熟悉,或者需要多种语言的例子?不过用户的问题里没有特别说明,可能默认是常见的语言,比如Python或者Java。不过原问题中的示例代码是Python的快速排,所以可能用户更倾向于Python。不过引用3是C++,需要确认。不过用户的问题里直接问的是如何用代码实现,所以可能需要提供多种方法,比如递归和迭代,以及不同语言的示例? 然后,根据引用3,递归算法相对简单,结构清晰。比如前遍历递归就是先访问根节点,然后递归左子树,再递归右子树。同样,中后序调整访问顺即可。但是用户可能需要递归和迭代两种方法,因为有时候迭代更高效,或者避免栈溢出的问题。引用3中的示例是递归的,但LeetCode也常要求迭代解法。所以可能需要同时给出递归和迭代的实现。 另外,引用1和4提到根据前和中重建二叉树,这可能和遍历有关联,但用户的问题主要是遍历的实现,而不是重建。不过可能需要简单提及遍历的应用,比如重建二叉树需要中加前后序,但用户的问题集中在遍历的实现方法。 现在,结构上可能需要分递归和迭代两部分,分别说明前、中后序的实现。对于递归,代码相对简单,调整访问顺即可。对于迭代,可能需要使用栈,处理顺不同。例如,前的迭代可以用栈,先压入根,然后循环弹出,访问后先压右再压左。中迭代则用栈和指针,先走到最左,再处理节点,再转向右子树。后序迭代相对复杂,可能需要两个栈,或者逆处理。 另外,用户可能需要代码示例的注释,解释每一步的作用。比如递归的终止条件,迭代中的栈操作等。还要注意代码的正确性,比如在Python中如何定义树的结构,可能需要先定义TreeNode类。但用户的问题可能更关注遍历算法本身,而不是树的结构定义,所以示例代码中可能需要包含一个简单的树结构定义。 例如,在Python中,可以定义一个TreeNode类,包含val、left、right属性。然后编写前、中后序的递归和迭代函数。比如递归前就是先append根的值,然后递归左,递归右。中则是先递归左,append根,再递归右。后序递归左、右,最后append根。 对于迭代的实现,前可以用栈,每次弹出节点,访问后先压右子节点,再压左子节点。中迭代需要维护当前节点指针,先走到最左,然后弹出栈顶,访问后处理右子树。后序迭代可以用一个栈,类似前,但顺调整为根-右-左,然后反转结果得到左-右-根的顺。或者用两个栈,第二个栈用来反转顺。 此外,层遍历可能不属于用户的问题范围,但引用3提到了层遍历,但用户的问题明确前、中、后序,所以可能不需要涉及层。 还需要注意代码的语法正确性,比如Python中的缩进,函数定义等。比如在递归函数中,可能需要将结果保存在一个列表中,可以通过传递列表作为参数,或者使用类的成员变量,或者使用嵌套函数。例如,在Python中,可以在函数内部定义递归辅助函数,或者通过修改外部列表。 比如,递归的前遍历函数可以这样写: def preorderTraversal(root): res = [] def helper(node): if not node: return res.append(node.val) helper(node.left) helper(node.right) helper(root) return res 类似地,中后序调整append的位置即可。 对于迭代版本,前的Python代码可能如下: def preorder_iterative(root): res = [] stack = [root] while stack: node = stack.pop() if node: res.append(node.val) stack.append(node.right) stack.append(node.left) return res 需要注意的是,栈中可能压入None节点,所以在弹出后需要判断是否为空。或者可以调整条件,只压入非空节点,但初始时可能root为空的情况需要处理。 中迭代: def inorder_iterative(root): res = [] stack = [] curr = root while curr or stack: while curr: stack.append(curr) curr = curr.left curr = stack.pop() res.append(curr.val) curr = curr.right return res 后序迭代的一种方法: def postorder_iterative(root): res = [] stack = [root] while stack: node = stack.pop() if node: res.append(node.val) stack.append(node.left) stack.append(node.right) return res[::-1] 这里先将根压栈,然后按根-右-左的顺处理,最后反转结果得到后序的左-右-根。 这样,用户可以得到递归和迭代的代码示例,并了解不同遍历的实现方式。 另外,用户可能想知道时间复杂度和空间复杂度。三种遍历的时间都是O(n),空间复杂度递归是O(h)(h为树的高度,栈空间),迭代法也是O(n),因为栈的大小最坏情况是O(n)(比如退化为链表)。 最后,根据用户提供的引用,特别是引用2提到后序遍历适用于表达式树,可能可以补充应用场景,但用户的问题集中在代码实现,所以可能不需要展开,但可以简要提及。 在总结时,需要确保代码示例正确,符合语法,并且解释清晰。可能需要检查每个遍历的步骤是否正确,例如迭代后序的实现是否确实通过反转前的变体得到正确结果。</think>### 二叉树的前、中后序遍历实现方法 二叉树遍历是基础算法问题,以下是递归和迭代两种实现方式,以Python为例(假设已定义`TreeNode`类,包含`val`、`left`、`right`属性)。 --- ### 1. 递归实现 递归方法通过调整节点访问顺实现不同遍历方式。 #### **前遍历**(根→左→右) ```python def preorder_recursive(root): res = [] def helper(node): if not node: return res.append(node.val) # 先访问根节点 helper(node.left) helper(node.right) helper(root) return res ``` #### **中遍历**(左→根→右) ```python def inorder_recursive(root): res = [] def helper(node): if not node: return helper(node.left) res.append(node.val) # 中间访问根节点 helper(node.right) helper(root) return res ``` #### **后序遍历**(左→右→根) ```python def postorder_recursive(root): res = [] def helper(node): if not node: return helper(node.left) helper(node.right) res.append(node.val) # 最后访问根节点 helper(root) return res ``` --- ### 2. 迭代实现 迭代方法通过栈模拟递归过程,控制节点访问顺。 #### **前遍历** ```python def preorder_iterative(root): res = [] stack = [root] while stack: node = stack.pop() if node: res.append(node.val) stack.append(node.right) # 先压右节点(后弹出) stack.append(node.left) # 后压左节点(先弹出) return res ``` #### **中遍历** ```python def inorder_iterative(root): res = [] stack = [] curr = root while curr or stack: while curr: # 走到最左子节点 stack.append(curr) curr = curr.left curr = stack.pop() res.append(curr.val) curr = curr.right # 转向右子树 return res ``` #### **后序遍历** ```python def postorder_iterative(root): res = [] stack = [root] while stack: node = stack.pop() if node: res.append(node.val) stack.append(node.left) # 先压左节点(后弹出) stack.append(node.right) # 后压右节点(先弹出) return res[::-1] # 反转根→右→左→结果为左→右→根 ``` --- ### 关键点说明 1. **时间复杂度**:所有方法均为$O(n)$,每个节点访问一次。 2. **空间复杂度**: - 递归方法:$O(h)$($h$为树的高度,递归栈深度)。 - 迭代方法:$O(n)$(最坏情况下栈空间占用)。 3. **应用场景**: - 前遍历:复制二叉树结构或列化[^2]。 - 中遍历:二叉搜索树的有输出。 - 后序遍历:表达式树的后缀计算[^2]。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值