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

• Difficulty Level : Easy
• 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)

My Personal Notes arrow_drop_up