LeetCode-Py 项目解析：二叉树的还原算法详解

LeetCode-Py 项目解析：二叉树的还原算法详解

LeetCode-Py ⛽️「算法通关手册」：超详细的「算法与数据结构」基础讲解教程，从零基础开始学习算法知识，800+ 道「LeetCode 题目」详细解析，200 道「大厂面试热门题目」。 项目地址: https://gitcode.com/gh_mirrors/le/LeetCode-Py

引言

二叉树是数据结构中最基础也是最重要的树形结构之一，在实际开发中有着广泛的应用。理解二叉树的遍历和还原原理，对于解决树形结构相关问题至关重要。本文将深入探讨如何通过不同的遍历序列组合来还原二叉树，并分析各种情况下的还原可能性。

二叉树的遍历序列与还原原理

遍历序列的特性

二叉树的三种基本遍历方式（前序、中序、后序）各自具有独特的性质：

1. 前序遍历：根节点 → 左子树 → 右子树
2. 中序遍历：左子树 → 根节点 → 右子树
3. 后序遍历：左子树 → 右子树 → 根节点

每种遍历序列都包含了二叉树的结构信息，但单独使用任何一种序列都无法唯一确定一棵二叉树。

还原二叉树的必要条件

要唯一确定一棵二叉树，至少需要两种遍历序列的组合：

1. 前序 + 中序：可以唯一确定二叉树
2. 中序 + 后序：可以唯一确定二叉树
3. 前序 + 后序：不能唯一确定二叉树（除非树中所有节点度为0或2）

这是因为中序遍历序列能够明确划分左右子树的范围，而前序或后序遍历序列能够确定根节点的位置。

从前序与中序遍历序列构造二叉树

算法思路

1. 前序遍历的第一个元素必然是根节点
2. 在中序遍历中找到该根节点，左侧即为左子树的中序遍历序列，右侧为右子树的中序遍历序列
3. 根据左子树的长度，在前序遍历中划分出左子树的前序遍历序列和右子树的前序遍历序列
4. 递归构建左右子树

代码实现

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        def createTree(preorder, inorder, n):
            if n == 0:
                return None
            k = 0
            while preorder[0] != inorder[k]:
                k += 1
            node = TreeNode(inorder[k])
            node.left = createTree(preorder[1: k + 1], inorder[0: k], k)
            node.right = createTree(preorder[k + 1:], inorder[k + 1:], n - k - 1)
            return node
        return createTree(preorder, inorder, len(inorder))

时间复杂度分析

• 最坏情况下（树退化为链表）时间复杂度为O(n²)
• 平均时间复杂度为O(nlogn)
• 空间复杂度为O(n)

从中序与后序遍历序列构造二叉树

算法思路

1. 后序遍历的最后一个元素必然是根节点
2. 在中序遍历中找到该根节点，左侧即为左子树的中序遍历序列，右侧为右子树的中序遍历序列
3. 根据左子树的长度，在后序遍历中划分出左子树的后序遍历序列和右子树的后序遍历序列
4. 递归构建左右子树

代码实现

class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
        def createTree(inorder, postorder, n):
            if n == 0:
                return None
            k = 0
            while postorder[n - 1] != inorder[k]:
                k += 1
            node = TreeNode(inorder[k])
            node.right = createTree(inorder[k + 1: n], postorder[k: n - 1], n - k - 1)
            node.left = createTree(inorder[0: k], postorder[0: k], k)
            return node
        return createTree(inorder, postorder, len(postorder))

注意事项

与从前序和中序构建二叉树相比，这里需要注意递归构建子树时先构建右子树再构建左子树，因为后序遍历的顺序是左→右→根。

从前序与后序遍历序列构造二叉树

特殊情况说明

虽然前序+后序不能唯一确定二叉树，但在某些特殊情况下可以构造出一棵可能的二叉树：

1. 树中所有节点的度都是0或2（没有度为1的节点）
2. 不要求构造的二叉树是唯一的

算法思路

1. 前序遍历的第一个元素是根节点
2. 假设前序遍历的第二个元素是左子树的根节点
3. 在后序遍历中找到左子树根节点的位置，划分左右子树
4. 递归构建左右子树

代码实现

class Solution:
    def constructFromPrePost(self, preorder: List[int], postorder: List[int]) -> TreeNode:
        def createTree(preorder, postorder, n):
            if n == 0:
                return None
            node = TreeNode(preorder[0])
            if n == 1:
                return node
            k = 0
            while postorder[k] != preorder[1]:
                k += 1
            node.left = createTree(preorder[1: k + 2], postorder[: k + 1], k + 1)
            node.right = createTree(preorder[k + 2: ], postorder[k + 1: -1], n - k - 2)
            return node
        return createTree(preorder, postorder, len(preorder))

实际应用与优化建议

实际应用场景

1. 序列化和反序列化二叉树
2. 数据库索引结构的重建
3. 表达式树的构建

优化建议

1. 可以使用哈希表存储中序遍历的值和索引，将查找操作从O(n)优化到O(1)
2. 对于大规模数据，可以考虑迭代法实现以避免递归深度过大
3. 在实际工程中，可以添加序列合法性检查，避免无效输入导致程序错误

总结

二叉树的还原是算法学习中的一个重要课题，理解不同遍历序列之间的关系对于解决树形结构问题至关重要。通过本文的分析，我们了解到：

1. 前序+中序或中序+后序可以唯一确定二叉树
2. 前序+后序不能唯一确定二叉树
3. 每种还原方法都有其特定的递归构建方式
4. 在实际应用中可以根据需求选择合适的还原方法

掌握这些还原算法不仅有助于解决LeetCode上的相关问题，更能加深对二叉树结构的理解，为处理更复杂的树形结构问题打下坚实基础。

LeetCode-Py ⛽️「算法通关手册」：超详细的「算法与数据结构」基础讲解教程，从零基础开始学习算法知识，800+ 道「LeetCode 题目」详细解析，200 道「大厂面试热门题目」。 项目地址: https://gitcode.com/gh_mirrors/le/LeetCode-Py