LeetCode - 解题笔记 - 106 - Construct Binary Tree from Inorder and Postorder Traversal

最新推荐文章于 2023-09-06 20:29:42 发布

支锦铭

最新推荐文章于 2023-09-06 20:29:42 发布

阅读量111

点赞数

分类专栏： LeetCode解题笔记文章标签：后序遍历二叉树重建递归算法哈希表先序遍历对偶问题

本文链接：https://blog.csdn.net/cary_leo/article/details/120969361

版权

LeetCode解题笔记专栏收录该内容

191 篇文章 1 订阅

订阅专栏

Solution 1

这个题是 0105. Construct Binary Tree from Preorder and Inorder Traversal 的对偶变体，二叉树的先序遍历和后续遍历实际上是对称的（但不是逆序！）。因此将上一个题的思路稍作调整即可：

对后续遍历序列从最后开始遍历，可以确定根节点
在确定左右子树区间之后，先右后左进行子树构建

时间复杂度： $O (N)$ ，其中 $N$ 为输入序列的长度，感谢哈希表！
空间复杂度： $O (N)$ ，其中 $N$ 为输入序列的长度，不考虑结果，有常数个状态变量和一个哈希表的空间占用

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        // 构造哈希表，常数时间查询索引
        this->indexPostOrder = postorder.size() - 1 ;
        for (int i = 0; i < inorder.size(); ++i) {
            this->v2i[inorder[i]] = i;
        }
        
        auto ans = this->_buildTree(postorder, 0, inorder.size() - 1);
        
        return ans;
    }
    
private:
    int indexPostOrder;
    unordered_map<int, int> v2i;
    
    TreeNode* _buildTree(vector<int>& postorder, int left, int right) {
        if (left > right) {
            return nullptr;
        }
        // cout << this->indexPostOrder << " " << left << " " << right << endl;
        // 向前构造的过程就是建树的过程
        auto value = postorder[this->indexPostOrder];
        TreeNode* node = new TreeNode(value);
        this->indexPostOrder--;
        
        auto indexInOrder = this->v2i[value];
        node->right = this->_buildTree(postorder, indexInOrder + 1, right);
        node->left = this->_buildTree(postorder, left, indexInOrder - 1);
        
        
        return node;
    }
};

Solution 2

Solution 1的Python实现

# 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 buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
        
        def _buildTree(left, right):
            nonlocal indexPostOrder
            
            if left > right: return None
            
            value = postorder[indexPostOrder]
            node = TreeNode(value)
            indexPostOrder -= 1
            
            indexInOrder = v2i[value]
            node.right = _buildTree(indexInOrder + 1, right)
            node.left =  _buildTree(left, indexInOrder - 1)
            
            return node
            
            
        indexPostOrder = len(postorder) - 1
        v2i = dict()
        for i in range(len(inorder)):
            v2i[inorder[i]] = i
            
        ans = _buildTree(0, len(inorder) - 1)
        
        return ans