106. Construct Binary Tree from Inorder and Postorder Traversal

最新推荐文章于 2022-01-01 11:35:53 发布

原创最新推荐文章于 2022-01-01 11:35:53 发布 · 152 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

45 篇文章

订阅专栏

本文介绍了一种改进的二叉树构建算法，通过优化内存使用，避免了内存溢出的问题。详细解释了原始版本中存在的问题，并展示了改进后的代码实现。

这道题难倒是不难，重点在于不引用vector的话，会内存溢出，借鉴一下：

原始版本：

class Solution {
public:
    //copy vec[i,j]
    vector<int> vectorCopy(vector<int>& vec, int i, int j) {
        if (i > j) {
            vector<int> newVec;
            return newVec;
        }
        vector<int> newVec;
        for (int k = i; k <= j; k++) {
            newVec.push_back(vec[k]);
        }
        return newVec;
    }

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        TreeNode* root;
        if (inorder.size() == 0) {
            root = NULL;
            return root;
        }
        else if (inorder.size() == 1) {
            root = new TreeNode(inorder[0]);
            return root;
        }
        else {
            root = new TreeNode(postorder[postorder.size() - 1]);
        }
        for (int i = 0; i < inorder.size(); i++) {
            if (inorder[i] == postorder[postorder.size() - 1]) {
                vector<int> inorderSun = vectorCopy(inorder, 0, i - 1);
                vector<int> postorderSun = vectorCopy(postorder, 0, i - 1);
                root->left = buildTree(inorderSun, postorderSun);
                inorderSun.clear(); postorderSun.clear();
                inorderSun = vectorCopy(inorder, i + 1, inorder.size() - 1);
                postorderSun = vectorCopy(postorder, i + 1, postorder.size() - 1);
                root->right = buildTree(inorderSun, postorderSun);
            }
        }
        return root;
    }
};

改进版本：

class Solution {
public:
    //[beginIndex, endIndex]
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder, int beginIn, int endIn, int beginPost, int endPost) {
        TreeNode* root;
        if (endIn < beginIn) {
            root = NULL;
            return root;
        }
        else if (endIn == beginIn) {
            root = new TreeNode(inorder[beginIn]);
            return root;
        }
        else {
            root = new TreeNode(postorder[endPost]);
        }
        for (int i = beginIn; i <= endIn; i++) {
            if (inorder[i] == postorder[endPost]) {
                root->left = buildTree(inorder, postorder, beginIn, i - 1, beginPost, beginPost + (i - 1) - beginIn);
                root->right = buildTree(inorder, postorder, i + 1, endIn, beginPost + (i - 1 - beginIn + 1), endPost - 1);
            }
        }
        return root;
    }

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        return buildTree(inorder, postorder, 0, inorder.size() - 1, 0, postorder.size() - 1);
    }
};