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

JehanRio

已于 2023-09-09 15:34:35 修改

阅读量92

点赞数

分类专栏： Leetcode专栏文章标签： leetcode 算法

于 2023-05-20 16:16:47 首次发布

本文链接：https://blog.csdn.net/weixin_51322383/article/details/130782788

版权

Leetcode专栏专栏收录该内容

278 篇文章 2 订阅

订阅专栏

文章目录

题目
代码（首刷看解析）
代码（二刷部分看解析）
代码（8.21 三刷部分看解析）
代码（9.9 四刷部分看解析）

题目

在这里插入图片描述

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

代码（首刷看解析）

/**
 * 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:
    unordered_map<int, int> val2indxe;
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        for(int i = 0; i < inorder.size(); i++) {
            val2indxe[inorder[i]] = i;
        }
        return build(preorder, 0, preorder.size() - 1, 
                    inorder, 0, inorder.size() - 1);
    }
    TreeNode* build(vector<int>& preorder, int preStart, int preEnd, 
                    vector<int>& inorder, int inStart, int inEnd) {
        if(preStart > preEnd)
            return nullptr;
        // root 节点对应的值就是前序遍历数组的第一个元素
        int rootVal = preorder[preStart];
        int index = val2indxe[rootVal];
        int leftSize = index - inStart;

        auto root = new TreeNode(rootVal);
        root->left = build(preorder, preStart + 1, preStart + leftSize, inorder, inStart, index-1);
        root->right = build(preorder, preStart + 1 + leftSize, preEnd, inorder, index+1, inEnd);
        return root;
    }
};

代码（二刷部分看解析）

class Solution {
public:
    unordered_map<int, int> val2inorder;
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        for(int i = 0; i < preorder.size(); i++) {
            val2inorder[inorder[i]] = i;
        }
        return build(preorder, 0, preorder.size()-1, inorder, 0, inorder.size()-1);
    }
    TreeNode* build(vector<int>& preorder, int preStart, int preEnd,
                    vector<int>& inorder, int inStart, int inEnd) {
        if(preStart > preEnd)
            return nullptr;
        int value = preorder[preStart];
        int index = val2inorder[value];
        int leftSize = index - inStart;
        auto root = new TreeNode(value);
        root->left = build(preorder, preStart+1, preStart+leftSize, inorder, inStart, index-1);
        root->right = build(preorder, preStart+1+leftSize, preEnd, inorder, index+1, inEnd);
        return root;
    }
};

代码（8.21 三刷部分看解析）

class Solution {
public:
    unordered_map<int, int> map;
    TreeNode* reConstructBinaryTree(vector<int>& preOrder, vector<int>& vinOrder) {    
        for(int i = 0; i < vinOrder.size(); i++) {
            map[vinOrder[i]] = i;
        }
        return build(preOrder, 0, preOrder.size() - 1, vinOrder, 0, vinOrder.size() - 1);
    }
    TreeNode* build(vector<int>& preOrder, int preLeft, int preRight, 
        vector<int>& vinOrder, int vinLeft, int vinRight) {
            if(preLeft > preRight) {
                return nullptr;
            }
            int index = map[preOrder[preLeft]];
            int preLen = index - vinLeft;
            auto root = new TreeNode(preOrder[preLeft]);
            root->left = build(preOrder, preLeft + 1, preLeft + preLen, vinOrder, vinLeft, index - 1);
            root->right = build(preOrder, preLeft + 1 + preLen, preRight, vinOrder, index+1, vinRight);
            return root;
    }
};

代码（9.9 四刷部分看解析）

class Solution {
public:
    unordered_map<int, int> mp;
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        for(int i = 0; i < inorder.size(); i++) {
            mp[inorder[i]] = i;
        }
        return build(preorder, 0, preorder.size()-1, inorder, 0, inorder.size()-1);
    }
    TreeNode* build(vector<int>& preorder, int preL, int preR, vector<int>& inorder, int inL, int inR) {
        if(preL > preR || inL > inR)
            return nullptr;
        int val = preorder[preL];
        int index = mp[val];
        int len = index - inL;
        auto root = new TreeNode(val);
        root->left = build(preorder, preL+1, preL+len, inorder, inL, index-1);
        root->right = build(preorder, preL+len+1, preR, inorder, index+1, inR);
        return root;
    }
};