GFG App
Open App
Browser
Continue

# Construct Binary Tree from String with bracket representation

Construct a binary tree from a string consisting of parenthesis and integers. The whole input represents a binary tree. It contains an integer followed by zero, one or two pairs of parenthesis. The integer represents the root’s value and a pair of parenthesis contains a child binary tree with the same structure. Always start to construct the left child node of the parent first if it exists.

Examples:

```Input : "1(2)(3)"
Output : 1 2 3
Explanation :
1
/ \
2   3
Explanation: first pair of parenthesis contains
left subtree and second one contains the right
subtree. Preorder of above tree is "1 2 3".

Input : "4(2(3)(1))(6(5))"
Output : 4 2 3 1 6 5
Explanation :
4
/   \
2     6
/ \   /
3   1 5   ```

We know first character in string is root. Substring inside the first adjacent pair of parenthesis is for left subtree and substring inside second pair of parenthesis is for right subtree as in the below diagram.

We need to find the substring corresponding to left subtree and substring corresponding to right subtree and then recursively call on both of the substrings.

For this first find the index of starting index and end index of each substring.
To find the index of closing parenthesis of left subtree substring, use a stack. Let the found index be stored in index variable.

## C++

 `/* C++ program to construct a binary tree from` `   ``the given string */` `#include ` `using` `namespace` `std;`   `/* A binary tree node has data, pointer to left` `   ``child and a pointer to right child */` `struct` `Node {` `    ``int` `data;` `    ``Node *left, *right;` `};` `/* Helper function that allocates a new node */` `Node* newNode(``int` `data)` `{` `    ``Node* node = (Node*)``malloc``(``sizeof``(Node));` `    ``node->data = data;` `    ``node->left = node->right = NULL;` `    ``return` `(node);` `}`   `/* This function is here just to test  */` `void` `preOrder(Node* node)` `{` `    ``if` `(node == NULL)` `        ``return``;` `    ``printf``(``"%d "``, node->data);` `    ``preOrder(node->left);` `    ``preOrder(node->right);` `}`   `// function to return the index of close parenthesis` `int` `findIndex(string str, ``int` `si, ``int` `ei)` `{` `    ``if` `(si > ei)` `        ``return` `-1;`   `    ``// Inbuilt stack` `    ``stack<``char``> s;`   `    ``for` `(``int` `i = si; i <= ei; i++) {`   `        ``// if open parenthesis, push it` `        ``if` `(str[i] == ``'('``)` `            ``s.push(str[i]);`   `        ``// if close parenthesis` `        ``else` `if` `(str[i] == ``')'``) {` `            ``if` `(s.top() == ``'('``) {` `                ``s.pop();`   `                ``// if stack is empty, this is` `                ``// the required index` `                ``if` `(s.empty())` `                    ``return` `i;` `            ``}` `        ``}` `    ``}` `    ``// if not found return -1` `    ``return` `-1;` `}`   `// function to construct tree from string` `Node* treeFromString(string str, ``int` `si, ``int` `ei)` `{` `    ``// Base case` `    ``if` `(si > ei)` `        ``return` `NULL;`   `    `  `      ``int` `num = 0;` `      ``// In case the number is having more than 1 digit` `      ``while``(si <= ei && str[si] >= ``'0'` `&& str[si] <= ``'9'``)` `    ``{` `      ``num *= 10;` `      ``num += (str[si] - ``'0'``);` `      ``si++;` `    ``}` `  `  `      ``// new root` `    ``Node* root = newNode(num);` `    ``int` `index = -1;`   `    ``// if next char is '(' find the index of` `    ``// its complement ')'` `    ``if` `(si <= ei && str[si] == ``'('``)` `        ``index = findIndex(str, si, ei);`   `    ``// if index found` `    ``if` `(index != -1) {`   `        ``// call for left subtree` `        ``root->left = treeFromString(str, si + 1, index - 1);`   `        ``// call for right subtree` `        ``root->right` `            ``= treeFromString(str, index + 2, ei - 1);` `    ``}` `    ``return` `root;` `}`   `// Driver Code` `int` `main()` `{` `    ``string str = ``"4(2(3)(1))(6(5))"``;` `    ``Node* root = treeFromString(str, 0, str.length() - 1);` `    ``preOrder(root);` `}`

## Java

 `/* Java program to construct a binary tree from` `   ``the given String */` `import` `java.util.*;` `class` `GFG` `{`   `  ``/* A binary tree node has data, pointer to left` `   ``child and a pointer to right child */` `  ``static` `class` `Node` `  ``{` `    ``int` `data;` `    ``Node left, right;` `  ``};`   `  ``/* Helper function that allocates a new node */` `  ``static` `Node newNode(``int` `data)` `  ``{` `    ``Node node = ``new` `Node();` `    ``node.data = data;` `    ``node.left = node.right = ``null``;` `    ``return` `(node);` `  ``}`   `  ``/* This function is here just to test  */` `  ``static` `void` `preOrder(Node node)` `  ``{` `    ``if` `(node == ``null``)` `      ``return``;` `    ``System.out.printf(``"%d "``, node.data);` `    ``preOrder(node.left);` `    ``preOrder(node.right);` `  ``}`   `  ``// function to return the index of close parenthesis` `  ``static` `int` `findIndex(String str, ``int` `si, ``int` `ei)` `  ``{` `    ``if` `(si > ei)` `      ``return` `-``1``;`   `    ``// Inbuilt stack` `    ``Stack s = ``new` `Stack<>();` `    ``for` `(``int` `i = si; i <= ei; i++)` `    ``{`   `      ``// if open parenthesis, push it` `      ``if` `(str.charAt(i) == ``'('``)` `        ``s.add(str.charAt(i));`   `      ``// if close parenthesis` `      ``else` `if` `(str.charAt(i) == ``')'``)` `      ``{` `        ``if` `(s.peek() == ``'('``)` `        ``{` `          ``s.pop();`   `          ``// if stack is empty, this is` `          ``// the required index` `          ``if` `(s.isEmpty())` `            ``return` `i;` `        ``}` `      ``}` `    ``}`   `    ``// if not found return -1` `    ``return` `-``1``;` `  ``}`   `  ``// function to construct tree from String` `  ``static` `Node treeFromString(String str, ``int` `si, ``int` `ei)` `  ``{`   `    ``// Base case` `    ``if` `(si > ei)` `      ``return` `null``;`   `    ``int` `num = ``0``;` `      ``// In case the number is having more than 1 digit` `      ``while``(si <= ei && str.charAt(si) >= ``'0'` `&& str.charAt(si) <= ``'9'``)` `    ``{` `      ``num *= ``10``;` `      ``num += (str.charAt(si) - ``'0'``);` `      ``si++;` `    ``}` `    ``si--;` `    ``// new root` `    ``Node root = newNode(num);` `    ``int` `index = -``1``;`   `    ``// if next char is '(' find the index of` `    ``// its complement ')'` `    ``if` `(si + ``1` `<= ei && str.charAt(si+``1``) == ``'('``)` `      ``index = findIndex(str, si + ``1``, ei);`   `    ``// if index found` `    ``if` `(index != -``1``)` `    ``{`   `      ``// call for left subtree` `      ``root.left = treeFromString(str, si + ``2``, index - ``1``);`   `      ``// call for right subtree` `      ``root.right` `        ``= treeFromString(str, index + ``2``, ei - ``1``);` `    ``}` `    ``return` `root;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``String str = ``"4(2(3)(1))(6(5))"``;` `    ``Node root = treeFromString(str, ``0``, str.length() - ``1``);` `    ``preOrder(root);` `  ``}` `}`   `// This code is contributed by gauravrajput1 `

## Python

 `# Python3 program to conStruct a` `# binary tree from the given String`   `# Helper class that allocates a new node`     `class` `newNode:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.left ``=` `self``.right ``=` `None`   `# This function is here just to test`     `def` `preOrder(node):` `    ``if` `(node ``=``=` `None``):` `        ``return` `    ``print``(node.data, end``=``' '``)` `    ``preOrder(node.left)` `    ``preOrder(node.right)`   `# function to return the index of` `# close parenthesis`     `def` `findIndex(``Str``, si, ei):` `    ``if` `(si > ei):` `        ``return` `-``1`   `    ``# Inbuilt stack` `    ``s ``=` `[]` `    ``for` `i ``in` `range``(si, ei ``+` `1``):`   `        ``# if open parenthesis, push it` `        ``if` `(``Str``[i] ``=``=` `'('``):` `            ``s.append(``Str``[i])`   `        ``# if close parenthesis` `        ``elif` `(``Str``[i] ``=``=` `')'``):` `            ``if` `(s[``-``1``] ``=``=` `'('``):` `                ``s.pop(``-``1``)`   `                ``# if stack is empty, this is` `                ``# the required index` `                ``if` `len``(s) ``=``=` `0``:` `                    ``return` `i` `    ``# if not found return -1` `    ``return` `-``1`   `# function to conStruct tree from String`     `def` `treeFromString(``Str``, si, ei):`   `    ``# Base case` `    ``if` `(si > ei):` `        ``return` `None`   `    ``# new root` `    ``root ``=` `newNode(``ord``(``Str``[si]) ``-` `ord``(``'0'``))` `    ``index ``=` `-``1`   `    ``# if next char is '(' find the` `    ``# index of its complement ')'` `    ``if` `(si ``+` `1` `<``=` `ei ``and` `Str``[si ``+` `1``] ``=``=` `'('``):` `        ``index ``=` `findIndex(``Str``, si ``+` `1``, ei)`   `    ``# if index found` `    ``if` `(index !``=` `-``1``):`   `        ``# call for left subtree` `        ``root.left ``=` `treeFromString(``Str``, si ``+` `2``,` `                                   ``index ``-` `1``)`   `        ``# call for right subtree` `        ``root.right ``=` `treeFromString(``Str``, index ``+` `2``,` `                                    ``ei ``-` `1``)` `    ``return` `root`     `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``Str` `=` `"4(2(3)(1))(6(5))"` `    ``root ``=` `treeFromString(``Str``, ``0``, ``len``(``Str``) ``-` `1``)` `    ``preOrder(root)`   `# This code is contributed by pranchalK`

## C#

 `/* C# program to construct a binary tree from` `   ``the given String */` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG` `{`   `  ``/* A binary tree node has data, pointer to left` `   ``child and a pointer to right child */` `  ``public`   ` ``class` `Node` `  ``{` `    ``public`   ` ``int` `data;` `    ``public`   ` ``Node left, right;` `  ``};`   `  ``/* Helper function that allocates a new node */` `  ``static` `Node newNode(``int` `data)` `  ``{` `    ``Node node = ``new` `Node();` `    ``node.data = data;` `    ``node.left = node.right = ``null``;` `    ``return` `(node);` `  ``}`   `  ``/* This function is here just to test  */` `  ``static` `void` `preOrder(Node node)` `  ``{` `    ``if` `(node == ``null``)` `      ``return``;` `    ``Console.Write(``"{0} "``, node.data);` `    ``preOrder(node.left);` `    ``preOrder(node.right);` `  ``}`   `  ``// function to return the index of close parenthesis` `  ``static` `int` `findIndex(String str, ``int` `si, ``int` `ei)` `  ``{` `    ``if` `(si > ei)` `      ``return` `-1;`   `    ``// Inbuilt stack` `    ``Stack<``char``> s = ``new` `Stack<``char``>();` `    ``for` `(``int` `i = si; i <= ei; i++)` `    ``{`   `      ``// if open parenthesis, push it` `      ``if` `(str[i] == ``'('``)` `        ``s.Push(str[i]);`   `      ``// if close parenthesis` `      ``else` `if` `(str[i] == ``')'``)` `      ``{` `        ``if` `(s.Peek() == ``'('``)` `        ``{` `          ``s.Pop();`   `          ``// if stack is empty, this is` `          ``// the required index` `          ``if` `(s.Count==0)` `            ``return` `i;` `        ``}` `      ``}` `    ``}`   `    ``// if not found return -1` `    ``return` `-1;` `  ``}`   `  ``// function to construct tree from String` `  ``static` `Node treeFromString(String str, ``int` `si, ``int` `ei)` `  ``{`   `    ``// Base case` `    ``if` `(si > ei)` `      ``return` `null``;`   `    ``int` `num = 0;` `      ``// In case the number is having more than 1 digit` `      ``while``(si <= ei && str[si] >= ``'0'` `&& str[si] <= ``'9'``)` `    ``{` `      ``num *= 10;` `      ``num += (str[si] - ``'0'``);` `      ``si++;` `    ``}` `    ``si--;` `    ``// new root` `    ``Node root = newNode(num);` `    ``int` `index = -1;`   `    ``// if next char is '(' find the index of` `    ``// its complement ')'` `    ``if` `(si + 1 <= ei && str[si+1] == ``'('``)` `      ``index = findIndex(str, si + 1, ei);`   `    ``// if index found` `    ``if` `(index != -1)` `    ``{`   `      ``// call for left subtree` `      ``root.left = treeFromString(str, si + 2, index - 1);`   `      ``// call for right subtree` `      ``root.right` `        ``= treeFromString(str, index + 2, ei - 1);` `    ``}` `    ``return` `root;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(String[] args)` `  ``{` `    ``String str = ``"4(2(3)(1))(6(5))"``;` `    ``Node root = treeFromString(str, 0, str.Length - 1);` `    ``preOrder(root);` `  ``}` `}`   `// This code is contributed by gauravrajput1 `

## Javascript

 `/* Javascript program to construct a binary tree from` `   ``the given String */`   ` ``/* A binary tree node has data, pointer to left` `   ``child and a pointer to right child */` `class Node` `{` `    ``constructor()` `    ``{` `        ``this``.data = 0;` `        ``this``.left = ``this``.right = ``null``;` `    ``}` `}`   `/* Helper function that allocates a new node */` `function` `newNode(data)` `{` `    ``let node = ``new` `Node();` `    ``node.data = data;` `    ``node.left = node.right = ``null``;` `    ``return` `(node);` `}`   `/* This function is here just to test  */` `function` `preOrder(node)` `{` `    ``if` `(node == ``null``)` `      ``return``;` `    ``console.log(node.data + ``" "``);` `    ``preOrder(node.left);` `    ``preOrder(node.right);` `}`   `  ``// function to return the index of close parenthesis` `function` `findIndex(str, si, ei)` `{` `    ``if` `(si > ei)` `      ``return` `-1;` ` `  `    ``// Inbuilt stack` `    ``let s = [];` `    ``for` `(let i = si; i <= ei; i++)` `    ``{` ` `  `      ``// if open parenthesis, push it` `      ``if` `(str[i] == ``'('``)` `        ``s.push(str[i]);` ` `  `      ``// if close parenthesis` `      ``else` `if` `(str[i] == ``')'``)` `      ``{` `        ``if` `(s[s.length-1] == ``'('``)` `        ``{` `          ``s.pop();` ` `  `          ``// if stack is empty, this is` `          ``// the required index` `          ``if` `(s.length == 0)` `            ``return` `i;` `        ``}` `      ``}` `    ``}` ` `  `    ``// if not found return -1` `    ``return` `-1;` `}`   `// function to construct tree from String` `function` `treeFromString(str,si,ei)` `{` `    ``// Base case` `    ``if` `(si > ei)` `      ``return` `null``;` ` `  `     ``let num = 0;` `      ``// In case the number is having more than 1 digit` `      ``while``(si <= ei && str[si] >= ``'0'` `&& str[si] <= ``'9'``)` `    ``{` `      ``num *= 10;` `      ``num += (str[si] - ``'0'``);` `      ``si++;` `    ``}` `    ``si--;` `    ``// new root` `    ``let root = newNode(num);` `    ``let index = -1;` ` `  `    ``// if next char is '(' find the index of` `    ``// its complement ')'` `    ``if` `(si + 1 <= ei && str[si + 1] == ``'('``)` `      ``index = findIndex(str, si + 1, ei);` ` `  `    ``// if index found` `    ``if` `(index != -1)` `    ``{` ` `  `      ``// call for left subtree` `      ``root.left = treeFromString(str, si + 2, index - 1);` ` `  `      ``// call for right subtree` `      ``root.right` `        ``= treeFromString(str, index + 2, ei - 1);` `    ``}` `    ``return` `root;` `}`   ` ``// Driver Code` `let str = ``"14(2(3)(1))(6(5))"``;` `let root = treeFromString(str, 0, str.length - 1);` `preOrder(root);`   `// This code is contributed by patel2127`

Output

`4 2 3 1 6 5 `

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

Another recursive approach:

Algorithm:

1. The very first element of the string is the root.
2. If the next two consecutive elements are “(” and “)”, this means there is no left child otherwise we will create and add the left child to the parent node recursively.
3. Once the left child is added recursively, we will look for consecutive “(” and add the right child to the parent node.
4. Encountering “)â€ť means the end of either left or right node and we will increment the start index
5. The recursion ends when the start index is greater than equal to the end index

## C++

 `#include ` `using` `namespace` `std;`   `// custom data type for tree building` `struct` `Node {` `    ``int` `data;` `    ``struct` `Node* left;` `    ``struct` `Node* right;` `    ``Node(``int` `val)` `    ``{` `        ``data = val;` `        ``left = right = NULL;` `    ``}` `};`   `// Below function accepts string and a pointer variable as` `// an argument` `// and draw the tree. Returns the root of the tree` `Node* constructtree(string s, ``int``* start)` `{` `    ``// Assuming there is/are no negative` `    ``// character/characters in the string` `    ``if` `(s.size() == 0 || *start >= s.size())` `        ``return` `NULL;`   `    ``// constructing a number from the continuous digits` `    ``int` `num = 0;` `    ``while` `(*start < s.size() && s[*start] != ``'('` `           ``&& s[*start] != ``')'``) {` `        ``int` `num_here = (``int``)(s[*start] - ``'0'``);` `        ``num = num * 10 + num_here;` `        ``*start = *start + 1;` `    ``}`   `    ``// creating a node from the constructed number from` `    ``// above loop` `    ``struct` `Node* root = NULL;` `      ``if``(num > 0)` `      ``root = ``new` `Node(num);`   `    ``// As soon as we see first right parenthesis from the` `    ``// current node we start to construct the tree in the` `    ``// left` `    ``if` `(*start < s.size() && s[*start] == ``'('``) {` `        ``*start = *start + 1;` `        ``root->left = constructtree(s, start);` `    ``}` `    ``if` `(*start < s.size() && s[*start] == ``')'``)` `    ``{` `      ``*start = *start + 1;` `      ``return` `root;` `    ``}`   `    ``// As soon as we see second right parenthesis from the` `    ``// current node we start to construct the tree in the` `    ``// right` `    ``if` `(*start < s.size() && s[*start] == ``'('``) {` `        ``*start = *start + 1;` `        ``root->right = constructtree(s, start);` `    ``}` `    ``if` `(*start < s.size() && s[*start] == ``')'``)` `        ``*start = *start + 1;` `    ``return` `root;` `}` `void` `preorder(Node* root)` `{` `    ``if` `(root == NULL)` `        ``return``;` `    ``cout << root->data << ``" "``;` `    ``preorder(root->left);` `    ``preorder(root->right);` `}` `int` `main()` `{` `    ``string s = ``"4(2(3)(1))(6(5))"``;` `    ``// cin>>s;` `    ``int` `start = 0;` `    ``Node* root = constructtree(s, &start);` `    ``preorder(root);` `    ``return` `0;` `}` `//This code is contributed by Chaitanya Sharma.`

## Java

 `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG{` `    `  `// Node class for the Tree` `static` `class` `Node` `{` `    ``int` `data;` `    ``Node left,right;` `    `  `    ``Node(``int` `data) ` `    ``{` `        ``this``.data = data;` `        ``this``.left = ``this``.right = ``null``;` `    ``}` `}`   `// static variable to point to the ` `// starting index of the string.` `static` `int` `start = ``0``;`   `// Construct Tree Function which accepts ` `// a string and return root of the tree;` `static` `Node constructTree(String s) ` `{` `    `  `    ``// Check for null or empty string` `    ``// and return null;` `    ``if` `(s.length() == ``0` `|| s == ``null``)` `    ``{` `        ``return` `null``;` `    ``}` `    `  `    ``if` `(start >= s.length())` `        ``return` `null``;` `    `  `    ``// Boolean variable to check` `    ``// for negative numbers` `    ``boolean` `neg = ``false``;` `    `  `    ``// Condition to check for negative number` `    ``if` `(s.charAt(start) == ``'-'``) ` `    ``{` `        ``neg = ``true``;` `        ``start++;` `    ``}` `    `  `    ``// This loop basically construct the` `    ``// number from the continuous digits ` `    ``int` `num = ``0``;` `    ``while` `(start < s.length() && ` `           ``Character.isDigit(s.charAt(start)))` `    ``{` `        ``int` `digit = Character.getNumericValue(` `            ``s.charAt(start));` `        ``num = num * ``10` `+ digit;` `        ``start++;` `    ``}` `    `  `    ``// If string contains - minus sign ` `    ``// then append - to the number;` `    ``if` `(neg) ` `        ``num = -num;` `    `  `    ``// Create the node object i.e. root of ` `    ``// the tree with data = num;` `    ``Node node = ``new` `Node(num);` `    `  `    ``if` `(start >= s.length()) ` `    ``{` `        ``return` `node;` `    ``}` `    `  `    ``// Check for open bracket and add the` `    ``// data to the left subtree recursively` `    ``if` `(start < s.length() && s.charAt(start) == ``'('` `)` `    ``{` `        ``start++;` `        ``node.left = constructTree(s);` `    ``}` `    `  `    ``if` `(start < s.length() && s.charAt(start) == ``')'``)` `    ``{` `        ``start++;` `        ``return` `node;` `    ``}` `    `  `    ``// Check for open bracket and add the data ` `    ``// to the right subtree recursively` `    ``if` `(start < s.length() && s.charAt(start) == ``'('``) ` `    ``{` `        ``start++;` `        ``node.right = constructTree(s);` `    ``}` `    `  `    ``if` `(start < s.length() && s.charAt(start) == ``')'``) ` `    ``{` `        ``start++;` `        ``return` `node;` `    ``}` `    ``return` `node;` `}`   `// Print tree function` `public` `static` `void` `printTree(Node node)` `{` `    ``if` `(node == ``null``)` `        ``return``;` `  `  `    ``System.out.println(node.data + ``" "``);` `    ``printTree(node.left);` `    ``printTree(node.right);` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    `  `    ``// Input` `    ``String s = ``"4(2(3)(1))(6(5))"``;` `  `  `    ``// Call the function construct tree` `    ``// to create the tree pass the string;` `    ``Node root = constructTree(s);` `  `  `    ``// Function to print preorder of the tree` `    ``printTree(root);` `}` `}`   `// This code is contributed by yash181999`

## Python3

 `class` `newNode:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.left ``=` `self``.right ``=` `None`     `def` `preOrder(node):` `    ``if` `(node ``=``=` `None``):` `        ``return` `    ``print``(node.data, end``=``" "``)` `    ``preOrder(node.left)` `    ``preOrder(node.right)`     `def` `treeFromStringHelper(si, ei, arr, root):`   `    ``if` `si[``0``] >``=` `ei:` `        ``return` `None`   `    ``if` `arr[si[``0``]] ``=``=` `"("``:`   `        ``if` `arr[si[``0``]``+``1``] !``=` `")"``:` `            ``if` `root.left ``is` `None``:` `                ``if` `si[``0``] >``=` `ei:` `                    ``return` `                ``new_root ``=` `newNode(arr[si[``0``]``+``1``])` `                ``root.left ``=` `new_root` `                ``si[``0``] ``+``=` `2` `                ``treeFromStringHelper(si, ei, arr, new_root)`   `        ``else``:` `            ``si[``0``] ``+``=` `2`   `        ``if` `root.right ``is` `None``:` `            ``if` `si[``0``] >``=` `ei:` `                ``return`   `            ``if` `arr[si[``0``]] !``=` `"("``:` `                ``si[``0``] ``+``=` `1` `                ``return`   `            ``new_root ``=` `newNode(arr[si[``0``]``+``1``])` `            ``root.right ``=` `new_root` `            ``si[``0``] ``+``=` `2` `            ``treeFromStringHelper(si, ei, arr, new_root)` `        ``else``:` `            ``return`   `    ``if` `arr[si[``0``]] ``=``=` `")"``:` `        ``if` `si[``0``] >``=` `ei:` `            ``return` `        ``si[``0``] ``+``=` `1` `        ``return`   `    ``return`     `def` `treeFromString(string):`   `    ``root ``=` `newNode(string[``0``])`   `    ``if` `len``(string) > ``1``:` `        ``si ``=` `[``1``]` `        ``ei ``=` `len``(string)``-``1`   `        ``treeFromStringHelper(si, ei, string, root)`   `    ``return` `root`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``Str` `=` `"4(2(3)(1))(6(5))"` `    ``root ``=` `treeFromString(``Str``)` `    ``preOrder(root)`   `# This code is contributed by dheerajalimchandani`

## C#

 `using` `System;` `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` `data)` `        ``{` `            ``this``.data = data;` `            ``left = right = ``null``;` `        ``}` `    ``}` `    `  `    ``// static variable to point to the` `    ``// starting index of the string.` `    ``static` `int` `start = 0;` `     `  `    ``// Construct Tree Function which accepts` `    ``// a string and return root of the tree;` `    ``static` `Node constructTree(``string` `s)` `    ``{` `         `  `        ``// Check for null or empty string` `        ``// and return null;` `        ``if` `(s.Length == 0 || s == ``null``)` `        ``{` `            ``return` `null``;` `        ``}` `         `  `        ``if` `(start >= s.Length)` `            ``return` `null``;` `         `  `        ``// Boolean variable to check` `        ``// for negative numbers` `        ``bool` `neg = ``false``;` `         `  `        ``// Condition to check for negative number` `        ``if` `(s[start] == ``'-'``)` `        ``{` `            ``neg = ``true``;` `            ``start++;` `        ``}` `         `  `        ``// This loop basically construct the` `        ``// number from the continuous digits` `        ``int` `num = 0;` `        ``while` `(start < s.Length &&` `               ``Char.IsDigit(s[start]))` `        ``{` `            ``int` `digit = (``int``)Char.GetNumericValue(` `                ``s[start]);` `            ``num = num * 10 + digit;` `            ``start++;` `        ``}` `         `  `        ``// If string contains - minus sign` `        ``// then append - to the number;` `        ``if` `(neg)` `            ``num = -num;` `         `  `        ``// Create the node object i.e. root of` `        ``// the tree with data = num;` `        ``Node node = ``new` `Node(num);` `         `  `        ``if` `(start >= s.Length)` `        ``{` `            ``return` `node;` `        ``}` `         `  `        ``// Check for open bracket and add the` `        ``// data to the left subtree recursively` `        ``if` `(start < s.Length && s[start] == ``'('` `)` `        ``{` `            ``start++;` `            ``node.left = constructTree(s);` `        ``}` `         `  `        ``if` `(start < s.Length && s[start] == ``')'``)` `        ``{` `            ``start++;` `            ``return` `node;` `        ``}` `         `  `        ``// Check for open bracket and add the data` `        ``// to the right subtree recursively` `        ``if` `(start < s.Length && s[start] == ``'('``)` `        ``{` `            ``start++;` `            ``node.right = constructTree(s);` `        ``}` `         `  `        ``if` `(start < s.Length && s[start] == ``')'``)` `        ``{` `            ``start++;` `            ``return` `node;` `        ``}` `        ``return` `node;` `    ``}` `     `  `    ``// Print tree function` `    ``static` `void` `printTree(Node node)` `    ``{` `        ``if` `(node == ``null``)` `            ``return``;` `       `  `        ``Console.Write(node.data + ``" "``);` `        ``printTree(node.left);` `        ``printTree(node.right);` `    ``}` `    `  `  ``// Driver code` `  ``static` `void` `Main()` `  ``{` `    `  `    ``// Input` `    ``string` `s = ``"4(2(3)(1))(6(5))"``;` `   `  `    ``// Call the function construct tree` `    ``// to create the tree pass the string;` `    ``Node root = constructTree(s);` `   `  `    ``// Function to print preorder of the tree` `    ``printTree(root);` `  ``}` `}`   `// This code is contributed by decode2207.`

## Javascript

 ``

Output

`4 2 3 1 6 5 `

Time complexity: O(n) where n is the length of the string.
Auxiliary space: O(n).

This article is contributed by Chhavi. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.