根据前序和后序遍历构造二叉树

文章讲述了如何根据给定的前序遍历和后序遍历序列,利用递归方法重构二叉树,难点在于确定左子树和右子树的结点个数。作者详细解释了确定左子树根节点的方法和递归构建树的过程。

1.题目

这道题是2024-2-22的签到题,题目难度为中等。

考察知识点为递归。

题目链接:889. 根据前序和后序遍历构造二叉树 - 力扣(LeetCode)

给定两个整数数组,preorder 和 postorder ,其中 preorder 是一个具有 无重复 值的二叉树的前序遍历,postorder 是同一棵树的后序遍历,重构并返回二叉树。

如果存在多个答案,您可以返回其中 任何 一个。

2.思路

昨天和家里人玩的太嗨了就只做了题目没有及时更新题解,小小的偷个懒嘿嘿。

题目难点

前两天的题目分别是根据前序与中序遍历序列构造二叉树、从中序与后序遍历序列构造二叉树,因此大体思路我们还是一样的,定义递归函数来构建树。但这道题有一个难点:我们如何确定每棵树的左子树总结点个数leftNum和右子树总结点个数rightNum,前两天我们是根据中序遍历序列来确定leftNum和rightNum的。那么我们重新看一下每一个遍历的顺序序列:

前序遍历数组:[根节点值,(左子树的所有结点值),(右子树的所有结点值)]

中序遍历数组:[(左子树的所有结点值),根节点值,(右子树的所有结点值)]

后序遍历数组:[(左子树的所有结点值),(右子树的所有结点值),根节点值]

很明显我们根据之前的思路只能确定根节点的值,那该怎么办呢?其实这个就要考察我们对树的遍历进一步理解了,下面是我一步一步的思路(可能有点啰嗦,但清晰易懂)。

确定左子树和右子树结点个数

对于同一棵树,它的前序遍历数组下标第一位肯定是根节点,前序遍历数组下标第二位肯定是它的左子结点(这个有点意思了,细品😜)当然我也画了一个简略图方便大家理解。

这样我们是不是可以找到左子树的根节点值了呀,下面这一步是见证奇迹的时候了。对于后序遍历数组,它的下标最后一位肯定是根节点对吧,那么我们是不是可以借助前面得到左子树根节点值来确定它在后序遍历数组的下标索引呢?下面是我画的一个图

有了左子树根节点的值,我们可以利用python的index函数来找到它在后序遍历序列中的下标索引,而后序遍历数组中从遍历开始下标pos_start到左子树根节点下标leftRootIndex这个区间是不是就是左子树区间呢?没错,这样我们就可以求出左子树结点个数leftNum了,然后就可以根据当前数组的pos_start和pos_end来进行相关逻辑相减得到右子树结点个数rightNum。

构建递归函数

同样的,我们需要定义一个递归函数构建我们的树,函数有4个参数,分别是:

pre_start:当前树的前序遍历开始索引

pre_end:当前树的前序遍历结束索引

pos_start:当前树的后序遍历开始索引

pos_end:当前树的后续i办理结束索引

递归核心逻辑

        对于一个正常的遍历序列,它的开始索引肯定是小于等于结束索引的(无论是前序遍历还是后序遍历),因此如果当pre_start>pre_end或pos_start>pos_end的时候,它需要返回None。

如果到了这里你觉得结束了那么不好意思,你这道题要卡住了,为啥,因为这道题我们有一个确定左子树根节点这一操作,根据前面的思路,当前树的左子结点下标索引是排第2位的,即:

preLeftRootIndex = pre_{parent} + 1

因此我们需要对这个preLeftRootIndex进行判断,如果不符合规则(leftRootIndex > pre_end),那么说明这个左子结点是个叶子节点(左子结点没有子结点了),则可以直接返回结点了。否则我们需要确定它在后序遍历数组中的下标索引:

posLeftRootIndex = postorder.index(LeftRootValue)

然后我们利用pos_start和刚才得到的posLeftRootIndex就可以确定左子树的长度了,不理解的还是可以看上面的图。

leftNum = posLeftRootIndex - posStart + 1

rightNum = preEnd - preStart - leftNum

其中,preEnd-preStart表示当前树的所有子树节点个数(leftNum + rightNum)。

到此我们就可以得到两颗子树的下标索引了,接下来就是构建树了,我们还是利用TreeNode来构建结点,然后我们还需要推导两颗子树的4个参数公式:

左子树参数公式

preStart_{son} = preStart_{parent} + 1

preEnd_{son} = preEnd_{parent} + leftNum

posStart_{son} = posStart_{parent}

posEnd_{son} = posStart_{parent} + leftNum - 1

右子树参数公式

preStart_{son} = preStart_{parent} + leftNum + 1

preEnd_{son} = preEnd_{parent}

posStart_{son} = posStart_{parent} + leftNum

posEnd_{son} = posEnd_{parent} - 1

3.代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def constructFromPrePost(self, preorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
        # 结点列表的长度
        length = len(preorder)

        # 递归函数,用于构建树
        def build(pre_start,pre_end,pos_start,pos_end):
            # 如果下标索引start>end,则返回None
            if pre_start > pre_end:
                return None
            # 先构建当前树的根节点
            root = TreeNode(preorder[pre_start])
            # 当前树的左子树根节点下标索引(左子结点下标索引)
            pre_leftRoot = pre_start + 1
            # 如果当前索引超出范围,则直接返回结点
            # 说明这个左子树是一个左子结点
            if pre_leftRoot > pre_end:
                return root
            # 求后序遍历数组中左子树根结点的下标索引
            pos_leftRoot = postorder.index(preorder[pre_leftRoot])
            # 左子树所有结点个数
            leftNum = pos_leftRoot - pos_start + 1
            # 右子树所有节点个数
            rightNum = pre_end - pre_start - leftNum
            # 递归构建左子树
            root.left = build(pre_start+1,pre_start+leftNum,pos_start,pos_start+leftNum-1)
            # 递归构建右子树
            root.right = build(pre_start+leftNum+1,pre_end,pos_start+leftNum,pos_end-1)

            return root
        
        return build(0,length-1,0,length-1)


            

                

<think>首先,用户要求我参考系统级指令。指令要求: 1. 所有行内数学表达式使用 `$...$` 格式。 2. 独立公式使用 `$$...$$` 并单独成段。 3. LaTeX 语法正确。 4. 使用中文回答。 5. 生成相关问题。 6. 引用的段落末尾添加引用标识,如 `[^1]`。 用户提供了一些引用: - 引用[1]:关于二叉树类在 Java 中的实现,包括插入遍历准备。 - 引用[2]:关于根据中序后序遍历序列构造二叉树的 Java 代码。 用户查询:"我想查找构造二叉树并实现前序、中序、后序遍历的方法"。所以,核心是解释如何构造二叉树(可能从遍历序列)并实现三种遍历。 我需要结构化回答。用户提到了"参考站内引用",所以我应该整合这些引用到我的回答中。 关键点: - 构造二叉树:用户提供的引用[2]展示了如何从中序后序遍历序列构造二叉树。所以,我应该解释这个方法。 - 实现遍历:引用[1]中的代码有插入节点的方法,但没有完整遍历实现。用户查询是关于实现前序、中序后序遍历,所以我需要补充实现这些遍历的方法。 在回答中,我需要使用中文,并确保所有数学表达式(如果有)使用正确的 LaTeX 格式。但在这个主题中,可能没有太多数学公式,遍历算法递归的,描述时可以用文字或代码。 系统指令要求生成相关问题,所以在回答结束时添加相关问题。 回答结构: 1. **介绍二叉树遍历**:简要解释前序、中序、后序遍历。 2. **构造二叉树**:从引用[2],解释如何从中序后序遍历序列构造二叉树。 3. **实现遍历方法**:添加代码或描述来展示如何在二叉树类中实现前序、中序后序遍历。 4. **完整代码示例**:结合引用,提供一个完整的 Java 示例,包括类定义、构造方法遍历方法。 5. **结尾**:自然地添加引用标识。 6. **相关问题**:生成几个相关问题。 引用标识:在适当的地方添加 `[^1]` `[^2]`。 用户查询是基于上一次的问题,但没有提供上下文。用户说"请尽可能多的参考用户上一次的问题你的回答",但在这个对话中,这是我第一次响应用户,所以假设这是初始查询。专注于当前查询。 生成相关问题:可以与二叉树遍历构造相关。 大纲回答: - **引言**:解释二叉树遍历的种类。 - **构造二叉树**:描述从中序后序序列构造的方法,基于引用[2]。 - **遍历实现**:在二叉树类中添加遍历方法。 - **代码示例**:提供完整的 Java 代码。 - **相关问题**:生成 2-3 个相关问题。 确保代码格式正确,使用代码块。 在回答中,添加引用标识:例如,当提到插入方法时引用[^1],提到构造方法时引用[^2]。 用户提供的引用内容: - [^1]: 二叉树类定义,有插入方法。 - [^2]: 从中序后序构造二叉树的代码。 用户想实现遍历,所以我需要扩展二叉树类来添加遍历方法。 完整步骤: 1. 定义二叉树类(如引用[1])。 2. 实现插入方法或构造方法(引用[1][2])。 3. 添加前序、中序、后序遍历方法。 在遍历实现中,引用[1]没有遍历代码,所以我需要添加它。 参考引用[2]的构造方法,但它使用 TreeNode,而不是 BinaryTree,类名不同。我需要统一类名以避免混淆。 在引用[1]中,类是 BinaryTree,在引用[2]中是 TreeNode。我应该使用 BinaryTree 来保持一致。 在回答中,我可以用 BinaryTree 类,集成所有。 最终代码示例: - 定义 BinaryTree 类(基于引用[1])。 - 添加遍历方法:preOrder(), inOrder(), postOrder()。 - 此外,可以添加从遍历序列构造的方法(基于引用[2]),但为了专注,主要为遍历实现。 用户指定了"构造二叉树并实现前序中序后序遍历",所以两者都需要。 最好提供一个示例,展示如何创建二叉树(例如使用插入方法)并调用遍历方法。 或者,如果从序列构造,那么展示那个。 回答结构: 1. **二叉树遍历简介**:解释前序、中序、后序。 2. **构造二叉树**:介绍两种方式:通过插入节点或从遍历序列构造。 - 插入方式:基于引用[1]。 - 序列构造方式:基于引用[2](中序后序)。 3. **遍历实现**:添加遍历方法到类中。 4. **完整示例**:代码演示。 5. **相关问题**。 使用中文。 </think>### 构造二叉树并实现前序、中序、后序遍历的方法 二叉树是一种常见的数据结构,其中每个节点最多有两个子节点(左子树右子树)。前序(preorder)、中序(inorder)后序(postorder)遍历二叉树的三种基本遍历方式: - **前序遍历**:根节点 → 左子树 → 右子树。 - **中序遍历**:左子树 → 根节点 → 右子树。 - **后序遍历**:左子树 → 右子树 → 根节点。 要构造二叉树并实现这些遍历,主要有两种方法:(1) 通过插入节点动态构建二叉树;(2) 根据给定的中序后序遍历序列(或中序前序遍历序列)重建二叉树。以下我将逐步解释这两种方法,并结合 Java 代码实现。代码基于提供的引用内容进行整合扩展。 #### 1. **构造二叉树的方法** - **方法一:通过插入节点动态构建** 创建一个二叉树类,支持插入节点操作。插入规则通常基于二叉搜索树(BST)的特性:左子节点值小于根节点值,右子节点值大于根节点值(也可以自定义规则)。这种方法简单直观,适用于手动添加节点的情况[^1]。 ```java public class BinaryTree { int data; // 节点数据 BinaryTree left; // 左子树 BinaryTree right; // 右子树 // 构造方法,初始化节点 public BinaryTree(int data) { this.data = data; left = null; right = null; } // 插入节点方法(基于BST规则) public void insert(BinaryTree root, int data) { if (data > root.data) { // 大于根节点则插入右子树 if (root.right == null) { root.right = new BinaryTree(data); } else { this.insert(root.right, data); } } else { // 小于或等于根节点则插入左子树 if (root.left == null) { root.left = new BinaryTree(data); } else { this.insert(root.left, data); } } } } ``` - **方法二:根据中序后序遍历序列构造二叉树** 如果给定二叉树的中序遍历序列后序遍历序列,可以递归地重建整棵树。后序遍历的最后一个元素是根节点,中序遍历中根节点左侧是左子树序列,右侧是右子树序列。然后递归处理左子树右子树序列[^2]。 ```java import java.util.Arrays; public class BinaryTree { int data; BinaryTree left; BinaryTree right; public BinaryTree(int data) { this.data = data; left = null; right = null; } // 静态方法:根据中序后序序列构造二叉树 public static BinaryTree buildTree(int[] inorder, int[] postorder) { if (inorder == null || postorder == null || inorder.length == 0 || postorder.length == 0) { return null; } int rootValue = postorder[postorder.length - 1]; BinaryTree root = new BinaryTree(rootValue); int i; for (i = 0; i < inorder.length; i++) { if (inorder[i] == rootValue) { break; // 在中序序列中找到根节点位置 } } // 分割序列:左子树右子树 int[] leftInorder = Arrays.copyOfRange(inorder, 0, i); int[] rightInorder = Arrays.copyOfRange(inorder, i + 1, inorder.length); int[] leftPostorder = Arrays.copyOfRange(postorder, 0, i); int[] rightPostorder = Arrays.copyOfRange(postorder, i, postorder.length - 1); // 递归构造子树 root.left = buildTree(leftInorder, leftPostorder); root.right = buildTree(rightInorder, rightPostorder); return root; } } ``` #### 2. **实现遍历方法** 在二叉树类中添加前序、中序后序遍历方法。遍历通常使用递归实现,核心是访问节点的顺序不同。以下是添加到 `BinaryTree` 类的遍历代码: ```java public class BinaryTree { // ... 之前的字段构造方法(见上面代码) ... // 前序遍历:根节点 → 左子树 → 右子树 public void preOrder(BinaryTree root) { if (root == null) return; System.out.print(root.data + " "); // 访问根节点 preOrder(root.left); preOrder(root.right); } // 中序遍历:左子树 → 根节点 → 右子树 public void inOrder(BinaryTree root) { if (root == null) return; inOrder(root.left); System.out.print(root.data + " "); // 访问根节点 inOrder(root.right); } // 后序遍历:左子树 → 右子树 → 根节点 public void postOrder(BinaryTree root) { if (root == null) return; postOrder(root.left); postOrder(root.right); System.out.print(root.data + " "); // 访问根节点 } } ``` #### 3. **完整示例:创建二叉树遍历** 以下是一个完整的 Java 示例,展示如何构造二叉树(使用插入方法)并执行三种遍历: ```java import java.util.Arrays; public class Main { public static void main(String[] args) { // 方法一:通过插入节点构建二叉树 BinaryTree root = new BinaryTree(10); // 创建根节点 root.insert(root, 5); root.insert(root, 15); root.insert(root, 3); root.insert(root, 7); // 执行遍历 System.out.print("前序遍历: "); root.preOrder(root); // 输出: 10 5 3 7 15 System.out.println(); System.out.print("中序遍历: "); root.inOrder(root); // 输出: 3 5 7 10 15 System.out.println(); System.out.print("后序遍历: "); root.postOrder(root); // 输出: 3 7 5 15 10 // 方法二:根据中序后序序列构造二叉树 int[] inorder = {3, 5, 7, 10, 15}; int[] postorder = {3, 7, 5, 15, 10}; BinaryTree constructedRoot = BinaryTree.buildTree(inorder, postorder); System.out.println("\n从序列构造后的中序遍历: "); constructedRoot.inOrder(constructedRoot); // 输出: 3 5 7 10 15 } } class BinaryTree { // 类定义与上述代码一致(包括insert/buildTree/preOrder/inOrder/postOrder方法) // ... } ``` **关键说明**: - **时间复杂度**:所有遍历方法的时间复杂度为 $O(n)$($n$ 是节点数),因为每个节点恰好访问一次。 - **空间复杂度**:递归遍历的空间复杂度为 $O(h)$($h$ 是树高),在最坏情况下(斜树)退化为 $O(n)$。 - **正确性**:插入方法基于二叉搜索树规则,确保遍历序列有序;序列构造方法依赖于中序序列的根节点位置分割[^1][^2]。 ####
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小人物₍˄·͈༝·͈˄*₎◞ ̑̑

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值