Related Articles

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

• Difficulty Level : Medium
• Last Updated : 23 Aug, 2021

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 ``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'``);` `    ``// Stack used to store the``    ``// previous root elements``    ``stack 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 stk = ``new` `Stack();``      ` `        ``// 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'``);``     ` `        ``// 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

 ``

Output:
`4 2 3 1 6 5`

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up