105. 从前序与中序遍历序列构造二叉树（2种递归方法）

最新推荐文章于 2022-07-01 16:44:07 发布

z-k

最新推荐文章于 2022-07-01 16:44:07 发布

阅读量284

点赞数

分类专栏： Leetcode Leetcode带思路

本文链接：https://blog.csdn.net/weixin_40673608/article/details/86584127

版权

Leetcode 同时被 2 个专栏收录

131 篇文章 3 订阅

订阅专栏

Leetcode带思路

98 篇文章 2 订阅

订阅专栏

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

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

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]

返回如下的二叉树：

法一：递归法拷贝数组

效率：16.47%

选preorder第一个元素作为根结点

选inorder中preorder第一个元素前的所有元素作为左子树的参数2，inorder中剩余的元素作为右子树的参数2

假设上面中的左子树的参数2的元素个数为k

选preorder中第一个元素后的k个元素作为左子树的参数1，preorder中剩余的元素作为右子树的参数1

递归构造左右子树

比如

/**
 * 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.empty()){
            return NULL;
        } 
        TreeNode *root = new TreeNode(preorder[0]);
        if(preorder.size() == 1)
            return root;
        
        vector<int> left_inorder,right_inorder;
        int i;
        for(i = 0; i < inorder.size(); i++){
            if(inorder[i] != preorder[0])
                left_inorder.push_back(inorder[i]);
            else
                break;
        }
        for(i++ ; i < inorder.size(); i++)
            right_inorder.push_back(inorder[i]);
        
        vector<int> left_preorder,right_preorder;
        for(i = 1; i <= left_inorder.size(); i++){
            left_preorder.push_back(preorder[i]);
        }
        for( ; i < preorder.size(); i++)
            right_preorder.push_back(preorder[i]);
        root -> left  = buildTree(left_preorder,  left_inorder);
        root -> right = buildTree(right_preorder, right_inorder);
        return root;
        
    }
};

数组每次都需要拷贝，所以效率低

法二：递归法传位置参数

效率：97.49%

把法一中对数组的拷贝转换成传对应起始位置参数和传长度参数

由于不需要拷贝数组，所以效率比较高

/**
 * 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, int loc1, int loc2, int l_ength){
        if(l_ength <= 0){
            return NULL;
        } 
        TreeNode *root = new TreeNode(preorder[loc1]);
        if(l_ength == 1)
            return root;
        
        int left_loc2;
        for(left_loc2 = loc2; left_loc2 <= loc2 + l_ength; left_loc2++){
            if(inorder[left_loc2] == preorder[loc1])
                break;
        }
        root -> left  = buildTree(preorder,
                                  inorder,
                                  loc1 + 1,
                                  loc2,
                                  left_loc2 - loc2);
        root -> right = buildTree(preorder,
                                  inorder,
                                  loc1 + left_loc2 - loc2 + 1,
                                  left_loc2 + 1,
                                  l_ength - left_loc2 + loc2 - 1);
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return buildTree(preorder, inorder, 0, 0, preorder.size());
    }
};