 Open in App
Not now

# 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
Related Articles