（树_13）构造二叉树

最新推荐文章于 2024-09-07 11:07:16 发布

Jasscical

最新推荐文章于 2024-09-07 11:07:16 发布

阅读量269

点赞数

分类专栏： leetcode刷题

本文链接：https://blog.csdn.net/qq_41472037/article/details/109018085

版权

leetcode刷题专栏收录该内容

58 篇文章 0 订阅

订阅专栏

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

根据一棵树的中序遍历与后序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出

中序遍历 inorder = [9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]
返回如下的二叉树：

3
/ \
9 20
/ \
15 7

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

注意:
你可以假设树中没有重复的元素。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：

3
/ \
9 20
/ \
15 7

参考资料：代码随想录

解题思路

后序：左右中

中序：左中右

分为以下几步：

1. 后序、中序是否为空，为空直接返回空树，否则进入后续步骤

2. 获取后序最后一个元素，作为根节点

3. 由后序最后一个元素在中序里找到分割点delimiter

4. 由分割点对中序进行分割成子序列：左中序，右中序

5. 然后对后序进行分割成子序列：左后序，右后序（需要借助左中序来判断分割点位置，详情看代码注释）

6. 递归构造左子树，右子树

注意区间：使用左闭右开的话，整个代码要保持这个规则，如果使用左开右闭，那么就保持左开右闭！不然数组很容易就越界了。

```cpp []
/**容易理解，但是耗费时空
 * 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* traverse(vector<int> & inorder, vector<int> &postorder){
        if(postorder.size() == 0) return nullptr;
        int rootValue = postorder[postorder.size()-1];
        TreeNode *root = new TreeNode(rootValue);
        
        if(postorder.size() == 1) return root;

        //从中序中找到切割下标
        int delimiterIdex;
        for(delimiterIdex=0; delimiterIdex < inorder.size(); delimiterIdex++){
            if(inorder[delimiterIdex] == rootValue) break;
        }
        //找到切割点，对中序进行切割，左闭右开
        vector<int> leftInorder(inorder.begin(), inorder.begin()+delimiterIdex);
        vector<int> rightInorder(inorder.begin()+delimiterIdex+1, inorder.end());

        //舍弃后序最后一个元素
        postorder.resize(postorder.size()-1);
        
        //对后序进行切割，需要借助一下左中序。这里是因为中序后序切割的两个子数组长度是一致这个原理来
        vector<int> leftPostorder(postorder.begin(), postorder.begin()+leftInorder.size());
        vector<int> rightPostorder(postorder.begin()+leftInorder.size(), postorder.end());

        //对分割后的中序、后序进行递归
        root->left = traverse(leftInorder, leftPostorder);
        root->right = traverse(rightInorder, rightPostorder);

        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size()==0 || postorder.size()==0) return nullptr;
        return traverse(inorder, postorder);
    }
};
```

```cpp []
/**不容易理解，但是节省时空，使用下标索引
 * 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* traverse(vector<int> & inorder, int inorderBegin, int inorderEnd, vector<int> &postorder, int postorderBegin, int postorderEnd){
        if(postorderBegin == postorderEnd) return nullptr;
        int rootValue = postorder[postorderEnd-1];
        TreeNode *root = new TreeNode(rootValue);
        
        if((postorderEnd - postorderBegin) == 1) return root;

        //从中序中找到切割下标
        int delimiterIdex;
        for(delimiterIdex=0; delimiterIdex < inorderEnd; delimiterIdex++){
            if(inorder[delimiterIdex] == rootValue) break;
        }
        //找到切割点，对中序进行切割
        int leftInorderBegin = inorderBegin;//左中序
        int leftInorderEnd = delimiterIdex;
        int rightInorderBegin = delimiterIdex+1;//右中序
        int rightInorderEnd = inorderEnd;

 

        //对后序进行切割，需要借助一下左中序。这里是因为中序后序切割的两个子数组长度是一致这个原理来
        int leftPostorderBegin = postorderBegin;//注意左闭右开原则
        int leftPostorderEnd = postorderBegin + (delimiterIdex - inorderBegin);
        int rightPostorderBegin = postorderBegin + (delimiterIdex - inorderBegin);
        int rightPostorderEnd = postorderEnd-1;


        //对分割后的中序、后序进行递归
        root->left = traverse(inorder, leftInorderBegin, leftInorderEnd, postorder, leftPostorderBegin, leftPostorderEnd);
        root->right = traverse(inorder, rightInorderBegin, rightInorderEnd, postorder, rightPostorderBegin, rightPostorderEnd);

        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size()==0 || postorder.size()==0) return nullptr;
        return traverse(inorder, 0, inorder.size(), postorder, 0, postorder.size());
    }
};
```

由前序、中序构造二叉树代码如下：

/**
 * 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>& preorder, vector<int>& inorder) {
        if(preorder.size() == 0 || inorder.size() == 0) return nullptr;
        
        int rootValue = preorder[0];
        TreeNode *node = new TreeNode(rootValue);
        if(preorder.size() == 1){
            return node;
        }
        
        //在中序中找到切割点
        int delimiterIndex;
        for(delimiterIndex=0; delimiterIndex < inorder.size(); delimiterIndex++){
            if(inorder[delimiterIndex] == rootValue) break;
        }

        //找到切割点后，切割中序成左中序、右中序
        vector<int> leftInorder(inorder.begin(), inorder.begin()+delimiterIndex);
        vector<int> rightInorder(inorder.begin()+delimiterIndex+1, inorder.end());

        //切割前序，结合左中序数组大小
        //前序第一个元素要舍弃
        vector<int> leftPreorder(preorder.begin()+1, preorder.begin()+1+leftInorder.size());
        vector<int> rightPreorder(preorder.begin()+1+leftInorder.size(), preorder.end());

        //递归构造左、右子树
        node->left = buildTree(leftPreorder, leftInorder);
        node->right = buildTree(rightPreorder, rightInorder);

        return node;

    }
};


作者：jasscical
链接：https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/solution/106you-zhong-xu-hou-xu-lai-gou-zao-er-cha-shu-by-j/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

/**下标索引法
 * 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* traverse(vector<int> &preorder, int preorderBegin, int preorderEnd, vector<int> &inorder, int inorderBegin, int inorderEnd){
        if(preorderBegin == preorderEnd) return nullptr;
        
        int rootValue = preorder[preorderBegin];
        TreeNode *node = new TreeNode(rootValue);
        
        if(preorderEnd-preorderBegin == 1) return node;

        //在 中序（左 中 右） 找切割点
        int delimiterIndex;
        for(delimiterIndex=inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++){
            if(inorder[delimiterIndex] == rootValue) break;
        }

        //根据切割点delimiterIndex,切割中序
        //左中序：[左边界，delimiterIndex), 右中序：[delimiterIndex+1，右边界)
        int leftInorder_l = inorderBegin;
        int leftInorder_r = delimiterIndex;
        int rightInorder_l = delimiterIndex+1;
        int rightInorder_r = inorderEnd;

        //根据切割点delimiterIndex,切割前序
        //左前序：[左边界，左中序size+delimiterIndex), 右前序：[delimiterIndex，右边界)
        int leftPreorder_l = preorderBegin+1;
        int leftPreorder_r = preorderBegin+1+(leftInorder_r -leftInorder_l);
        int rightPreorder_l = preorderBegin+1+(leftInorder_r -leftInorder_l);
        int rightPreorder_r = preorderEnd;

        //递归构造 左、右子树
        node->left = traverse(preorder, leftPreorder_l, leftPreorder_r, inorder, leftInorder_l, leftInorder_r);
        node->right = traverse(preorder, rightPreorder_l, rightPreorder_r, inorder, rightInorder_l, rightInorder_r);

        return node;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size() == 0 || inorder.size() == 0) return nullptr; 
        return traverse(preorder, 0, preorder.size(), inorder, 0, inorder.size());
    }
};


作者：jasscical
链接：https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/solution/106you-zhong-xu-hou-xu-lai-gou-zao-er-cha-shu-by-j/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。