Skip to content
Related Articles

Related Articles

Construct a Binary Tree from String with bracket representation | Set 2

View Discussion
Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 23 Aug, 2021
View Discussion
Improve Article
Save Article

Given a string s consisting of parentheses {‘(‘ and ‘)’} and integers, the task is to construct a Binary Tree from it and print its Preorder traversal.

Examples:

Input: S = “1(2)(3)”
Output: 1 2 3
Explanation: The corresponding binary tree is as follows:
            1
          /   \                      
        2     3                       

Input: “4(2(3)(1))(6(5))”
Output: 4 2 3 1 6 5
Explanation:
The corresponding binary tree is as follows:

              4
           /     \                  
         2       6          
      /  \     /                        
   3    1   5                       

Recursive Approach: Refer to the previous article to solve the problem recursively. 
Time Complexity: O(N2
Auxiliary Space: O(N)

 

Approach: This problem can be solved using stack data structure. Follow the steps below to solve the problem:

 

  • Update the character at position 0 as root of the binary tree and initialize a stack stk.
  • Iterate in the range [1, N-1] using the variable i: 
    • If ‘(‘ is encountered, push the root to the stack stk.
    • Otherwise, if ‘)’ is encountered update root as the topmost element of the stack and pop the topmost element.
    • Otherwise, if the character is a number, then, branch into the part that is null (left or right).
  • At the end of the above steps, return the root node of the binary tree.

 

Below is the implementation of the above approach:

 

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Build a tree node having left and
// right pointers set to null initially
struct Node {
    Node* left;
    Node* right;
    int data;
 
    // Constructor to set the data of
    // the newly created tree node
    Node(int element)
    {
        data = element;
        this->left = nullptr;
        this->right = nullptr;
    }
};
 
// Utility function to print
// preorder traversal of the tree
void preorder(Node* root)
{
    if (!root)
        return;
 
    cout << root->data << " ";
    preorder(root->left);
    preorder(root->right);
}
 
// Function to construct a
// tree using bracket notation
Node* constructTree(string s)
{
 
    // First character is the root of the tree
    Node* root = new Node(s[0] - '0');
 
    // Stack used to store the
    // previous root elements
    stack<Node*> stk;
 
    // Iterate over remaining characters
    for (int i = 1; i < s.length(); i++) {
 
        // If current character is '('
        if (s[i] == '(') {
 
            // Push root into stack
            stk.push(root);
        }
 
        // If current character is ')'
        else if (s[i] == ')') {
 
            // Make root the top most
            // element in the stack
            root = stk.top();
 
            // Remove the top node
            stk.pop();
        }
 
        // If current character is a number
        else {
 
            // If left is null, then put the new
            // node to the left and move to the
            // left of the root
            if (root->left == nullptr) {
 
                Node* left = new Node(s[i] - '0');
                root->left = left;
                root = root->left;
            }
 
            // Otherwise, if right is null, then
            // put the new node to the right and
            // move to the right of the root
            else if (root->right == nullptr) {
 
                Node* right = new Node(s[i] - '0');
                root->right = right;
                root = root->right;
            }
        }
    }
 
    // Return the root
    return root;
}
 
// Driver code
int main()
{
    // Input
    string s = "4(2(3)(1))(6(5))";
 
    // Function calls
    Node* root = constructTree(s);
    preorder(root);
 
    return 0;
}

Java




// Java program for the above approach
import java.util.*;
public class Main
{
    // Class containing left and
    // right child of current
    // node and key value
    static class Node {
        
        public int data;
        public Node left, right;
        
        public Node(int element)
        {
            data = element;
            left = right = null;
        }
    }
     
    // Utility function to print
    // preorder traversal of the tree
    static void preorder(Node root)
    {
        if (root == null)
            return;
       
        System.out.print(root.data + " ");
        preorder(root.left);
        preorder(root.right);
    }
       
    // Function to construct a
    // tree using bracket notation
    static Node constructTree(String s)
    {
       
        // First character is the root of the tree
        Node root = new Node(s.charAt(0) - '0');
       
        // Stack used to store the
        // previous root elements
        Stack<Node> stk = new Stack<Node>();
       
        // Iterate over remaining characters
        for (int i = 1; i < s.length(); i++) {
       
            // If current character is '('
            if (s.charAt(i) == '(') {
       
                // Push root into stack
                stk.push(root);
            }
       
            // If current character is ')'
            else if (s.charAt(i) == ')') {
       
                // Make root the top most
                // element in the stack
                root = stk.peek();
       
                // Remove the top node
                stk.pop();
            }
       
            // If current character is a number
            else {
       
                // If left is null, then put the new
                // node to the left and move to the
                // left of the root
                if (root.left == null) {
       
                    Node left = new Node(s.charAt(i) - '0');
                    root.left = left;
                    root = root.left;
                }
       
                // Otherwise, if right is null, then
                // put the new node to the right and
                // move to the right of the root
                else if (root.right == null) {
       
                    Node right = new Node(s.charAt(i) - '0');
                    root.right = right;
                    root = root.right;
                }
            }
        }
       
        // Return the root
        return root;
    }
     
    public static void main(String[] args) {
        // Input
        String s = "4(2(3)(1))(6(5))";
       
        // Function calls
        Node root = constructTree(s);
        preorder(root);
    }
}
 
// This code is contributed by divyesh072019.

Python3




# Python program for the above approach
 
# Build a tree node having left and
# right pointers set to null initially
class Node:
    # Constructor to set the data of
    # the newly created tree node
    def __init__(self, element):
        self.data = element
        self.left = None
        self.right = None
 
# Utility function to print
# preorder traversal of the tree
def preorder(root):
    if (not root):
        return
 
    print(root.data, end = " ")
    preorder(root.left)
    preorder(root.right)
 
# Function to construct a
# tree using bracket notation
def constructTree(s):
 
    # First character is the root of the tree
    root = Node(ord(s[0]) - ord('0'))
 
    # Stack used to store the
    # previous root elements
    stk = []
 
    # Iterate over remaining characters
    for i in range(1,len(s)):
        # If current character is '('
        if (s[i] == '('):
 
            # Push root into stack
            stk.append(root)
 
        # If current character is ')'
        elif (s[i] == ')'):
 
            # Make root the top most
            # element in the stack
            root = stk[-1]
 
            # Remove the top node
            del stk[-1]
        # If current character is a number
        else:
 
            # If left is null, then put the new
            # node to the left and move to the
            # left of the root
            if (root.left == None):
 
                left = Node(ord(s[i]) - ord('0'))
                root.left = left
                root = root.left
 
            # Otherwise, if right is null, then
            # put the new node to the right and
            # move to the right of the root
            elif (root.right == None):
 
                right =  Node(ord(s[i]) - ord('0'))
                root.right = right
                root = root.right
 
    # Return the root
    return root
 
# Driver code
if __name__ == '__main__':
    # Input
    s = "4(2(3)(1))(6(5))"
 
    # Function calls
    root = constructTree(s)
    preorder(root)
 
# This code is contributed by mohit kumar 29.

C#




// C# program for the above approach
using System;
using System.Collections;
class GFG
{
     
    // Class containing left and
    // right child of current
    // node and key value
    class Node {
       
        public int data;
        public Node left, right;
       
        public Node(int element)
        {
            data = element;
            left = right = null;
        }
    }
     
    // Utility function to print
    // preorder traversal of the tree
    static void preorder(Node root)
    {
        if (root == null)
            return;
      
        Console.Write(root.data + " ");
        preorder(root.left);
        preorder(root.right);
    }
      
    // Function to construct a
    // tree using bracket notation
    static Node constructTree(string s)
    {
      
        // First character is the root of the tree
        Node root = new Node(s[0] - '0');
      
        // Stack used to store the
        // previous root elements
        Stack stk = new Stack();
      
        // Iterate over remaining characters
        for (int i = 1; i < s.Length; i++) {
      
            // If current character is '('
            if (s[i] == '(') {
      
                // Push root into stack
                stk.Push(root);
            }
      
            // If current character is ')'
            else if (s[i] == ')') {
      
                // Make root the top most
                // element in the stack
                root = (Node)(stk.Peek());
      
                // Remove the top node
                stk.Pop();
            }
      
            // If current character is a number
            else {
      
                // If left is null, then put the new
                // node to the left and move to the
                // left of the root
                if (root.left == null) {
      
                    Node left = new Node(s[i] - '0');
                    root.left = left;
                    root = root.left;
                }
      
                // Otherwise, if right is null, then
                // put the new node to the right and
                // move to the right of the root
                else if (root.right == null) {
      
                    Node right = new Node(s[i] - '0');
                    root.right = right;
                    root = root.right;
                }
            }
        }
      
        // Return the root
        return root;
    }
 
  // Driver code
  static void Main()
  {
     
    // Input
    string s = "4(2(3)(1))(6(5))";
  
    // Function calls
    Node root = constructTree(s);
    preorder(root);
  }
}
 
// This code is contributed by decode2207.

Javascript




<script>
    // Javascript program for the above approach  
    class Node
    {
        constructor(element) {
           this.left = null;
           this.right = null;
           this.data = element;
        }
    }
     
    // Utility function to print
    // preorder traversal of the tree
    function preorder(root)
    {
        if (root == null)
            return;
 
        document.write(root.data + " ");
        preorder(root.left);
        preorder(root.right);
    }
 
    // Function to construct a
    // tree using bracket notation
    function constructTree(s)
    {
 
        // First character is the root of the tree
        let root = new Node(s[0].charCodeAt() - '0'.charCodeAt());
 
        // Stack used to store the
        // previous root elements
        let stk = [];
 
        // Iterate over remaining characters
        for (let i = 1; i < s.length; i++) {
 
            // If current character is '('
            if (s[i] == '(') {
 
                // Push root into stack
                stk.push(root);
            }
 
            // If current character is ')'
            else if (s[i] == ')') {
 
                // Make root the top most
                // element in the stack
                root = stk[stk.length - 1];
 
                // Remove the top node
                stk.pop();
            }
 
            // If current character is a number
            else {
 
                // If left is null, then put the new
                // node to the left and move to the
                // left of the root
                if (root.left == null) {
 
                    let left = new Node(s[i].charCodeAt() - '0'.charCodeAt());
                    root.left = left;
                    root = root.left;
                }
 
                // Otherwise, if right is null, then
                // put the new node to the right and
                // move to the right of the root
                else if (root.right == null) {
 
                    let right = new Node(s[i].charCodeAt() - '0'.charCodeAt());
                    root.right = right;
                    root = root.right;
                }
            }
        }
 
        // Return the root
        return root;
    }
     
    // Input
    let s = "4(2(3)(1))(6(5))";
  
    // Function calls
    let root = constructTree(s);
    preorder(root);
 
// This code is contributed by divyeshrabadiya07.
</script>

 
 

Output: 

4 2 3 1 6 5

 

 

Time Complexity: O(N)
Auxiliary Space: O(N)

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!