Tags

  • AWS (7)
  • Apigee (3)
  • ArchLinux (5)
  • Array (6)
  • Backtracking (6)
  • BinarySearch (6)
  • C++ (19)
  • CI&CD (3)
  • Calculus (2)
  • DesignPattern (43)
  • DisasterRecovery (1)
  • Docker (8)
  • DynamicProgramming (20)
  • FileSystem (11)
  • Frontend (2)
  • FunctionalProgramming (1)
  • GCP (1)
  • Gentoo (6)
  • Git (15)
  • Golang (1)
  • Graph (10)
  • GraphQL (1)
  • Hardware (1)
  • Hash (1)
  • Kafka (1)
  • LinkedList (13)
  • Linux (27)
  • Lodash (2)
  • MacOS (3)
  • Makefile (1)
  • Map (5)
  • MathHistory (1)
  • MySQL (21)
  • Neovim (10)
  • Network (66)
  • Nginx (6)
  • Node.js (33)
  • OpenGL (6)
  • PriorityQueue (1)
  • ProgrammingLanguage (9)
  • Python (10)
  • RealAnalysis (20)
  • Recursion (3)
  • Redis (1)
  • RegularExpression (1)
  • Ruby (19)
  • SQLite (1)
  • Sentry (3)
  • Set (4)
  • Shell (3)
  • SoftwareEngineering (12)
  • Sorting (2)
  • Stack (4)
  • String (2)
  • SystemDesign (13)
  • Terraform (2)
  • Tree (24)
  • Trie (2)
  • TwoPointers (16)
  • TypeScript (3)
  • Ubuntu (4)
  • Home

    Construct Binary Tree from Preorder and Inorder Traversal

    Published Sep 23, 2019 [  Tree  ]

    Given preorder and inorder traversal of a tree, construct the binary tree.

    Example

    Given

    preorder = [3,9,20,15,7]
    inorder = [9,3,15,20,7]
    

    we get

        3
       / \
      9  20
        /  \
       15   7
    

    Thoughts

    1. The first element in preorder array is the root of the tree.
    2. each element in preorder array divides the tree into the left part and right part

    Code

    /**
     * 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) {
            unordered_map<int, int> inorderValueToIndex;
            
            for(auto i = 0; i < inorder.size(); i++){
                inorderValueToIndex[inorder[i]] = i;
            }
            
            auto preorderIndex = 0;
            auto root = build(0, preorder.size() - 1, inorderValueToIndex, preorderIndex, preorder);
            
            return root;
        }
        TreeNode* build(int start, int end, unordered_map<int, int>& inorderValueToIndex, int& preorderIndex, vector<int>& preorder){
            if(start > end) {
                return nullptr;
            }
            
            auto val = preorder[preorderIndex++];
            auto node = new TreeNode(val);
            auto mid = inorderValueToIndex[val];
            
            node->left = build(start, mid - 1, inorderValueToIndex, preorderIndex, preorder);
            node->right = build(mid + 1, end, inorderValueToIndex, preorderIndex, preorder);
            
            return node;
        }
    };
    

    Reference: https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/