LeetCode-105. Construct Binary Tree from Preorder and Inorder Traversal [C++][Java]

LeetCode-105. Construct Binary Tree from Preorder and Inorder TraversalLevel up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/

Given two integer arrays preorder and inorder where preorder is the preorder traversal of a binary tree and inorder is the inorder traversal of the same tree, construct and return the binary tree.

Example 1:

Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
Output: [3,9,20,null,null,15,7]

Example 2:

Input: preorder = [-1], inorder = [-1]
Output: [-1]

Constraints:

1 <= preorder.length <= 3000inorder.length == preorder.length-3000 <= preorder[i], inorder[i] <= 3000preorder and inorder consist of unique values.Each value of inorder also appears in preorder.preorder is guaranteed to be the preorder traversal of the tree.inorder is guaranteed to be the inorder traversal of the tree.

class Solution {
public:
    TreeNode* buildTree(vector& preorder, vector& inorder) {
        return R(preorder, 0, preorder.size(), inorder, 0, inorder.size());
    }
    
    TreeNode* R(vector& a, int aBegin, int aEnd, vector& b, int bBegin, int bEnd) {
        if (aBegin >= aEnd || bBegin >= bEnd) {return nullptr;}
        TreeNode* root = new TreeNode(a[aBegin]);
        int pivot = bBegin;
        while (pivot < bEnd && b[pivot] != a[aBegin]) {pivot++;}
        root->left = R(a, aBegin+1, aBegin+1+pivot-bBegin, b, bBegin, pivot);
        root->right = R(a, aBegin+1+pivot-bBegin, aEnd, b, pivot+1, bEnd);
        return root;
    }  
};

class Solution {
public:
    TreeNode* buildTree(vector& preorder, vector& inorder) {
        if(preorder.size() == 0) return nullptr;
        unordered_map order;
        for(int i = 0;i < inorder.size();i++) order[inorder[i]] = i;
        TreeNode* out = new TreeNode(preorder[0]);
        stack stak;
        stak.push(out);
        for(int i = 1;i < preorder.size();i++) {
            int n = preorder[i];
            if(stak.empty()){
                out -> right = new TreeNode(n);
                stak.push(new TreeNode(n));
            } else {
                TreeNode* now = stak.top();
                if(order[now -> val] > order[n]) {
                    TreeNode* left = new TreeNode(n);
                    stak.push(left);
                    now -> left = left;
                } else {
                    while(!stak.empty() && order[stak.top() -> val] < order[n]) {
                        now = stak.top();
                        stak.pop();
                    }
                    TreeNode* right = new TreeNode(n);
                    now -> right = right;
                    stak.push(right);
                }
            }
        }
        return out;
    }
};

递归

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return R(preorder, 0, preorder.length, inorder, 0, inorder.length);
    }

    private TreeNode R(int[] a, int aBegin, int aEnd, int[] b, int bBegin, int bEnd) {
        if (aBegin >= aEnd || bBegin >= bEnd) {return null;}
        TreeNode root = new TreeNode(a[aBegin]);
        int pivot = bBegin;
        for (; pivot