# Binary tree to string with brackets

Construct a string consists of parenthesis and integers from a binary tree with the preorder traversing way.
The null node needs to be represented by empty parenthesis pair “()”. Omit all the empty parenthesis pairs that don’t affect the one-to-one mapping relationship between the string and the original binary tree.

Examples:

```Input : Preorder: [1, 2, 3, 4]
1
/   \
2     3
/
4
Output: "1(2(4))(3)"
Explanation: Originally it needs to be "1(2(4)
())(3()())", but we need to omit all the
unnecessary empty parenthesis pairs.
And it will be "1(2(4))(3)".

Input : Preorder: [1, 2, 3, null, 4]
1
/   \
2     3
\
4
Output: "1(2()(4))(3)"
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

This is opposite of Construct Binary Tree from String with bracket representation

The idea is to do the preorder traversal of the given Binary Tree along with this, we need to make use of braces at appropriate positions. But, we also need to make sure that we omit the unnecessary braces. We print the current node and call the same given function for the left and the right children of the node in that order(if they exist). For every node encountered, the following cases are possible.

Case 1: Both the left child and the right child exist for the current node. In this case, we need to put the braces () around both the left child’s preorder traversal output and the right child’s preorder traversal output.

Case 2: None of the left or the right child exist for the current node. In this case, as shown in the figure below, considering empty braces for the null left and right children is redundant. Hence, we need not put braces for any of them.

Case 3: Only the left child exists for the current node. As the figure below shows, putting empty braces for the right child in this case is unnecessary while considering the preorder traversal. This is because the right child will always come after the left child in the preorder traversal. Thus, omitting the empty braces for the right child also leads to same mapping between the string and the binary tree.

Case 4: Only the right child exists for the current node. In this case, we need to consider the empty braces for the left child. This is because, during the preorder traversal, the left child needs to be considered first. Thus, to indicate that the child following the current node is a right child we need to put a pair of empty braces for the left child.

## C++

 `/* C++ program to construct string from binary tree*/` `#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); ` `} ` ` `  `// Function to construct string from binary tree ` `void` `treeToString(Node* root, string& str) ` `{ ` `    ``// bases case ` `    ``if` `(root == NULL) ` `        ``return``; ` ` `  `    ``// push the root data as character ` `    ``str.push_back(root->data + ``'0'``); ` ` `  `    ``// if leaf node, then return ` `    ``if` `(!root->left && !root->right) ` `        ``return``; ` ` `  `    ``// for left subtree ` `    ``str.push_back(``'('``); ` `    ``treeToString(root->left, str); ` `    ``str.push_back(``')'``); ` ` `  `    ``// only if right child is present to  ` `    ``// avoid extra parenthesis ` `    ``if` `(root->right) { ` `        ``str.push_back(``'('``); ` `        ``treeToString(root->right, str); ` `        ``str.push_back(``')'``); ` `    ``} ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``/* Let us construct below tree ` `                ``1 ` `               ``/ \ ` `              ``2   3 ` `             ``/ \   \ ` `            ``4   5   6    */` `    ``struct` `Node* root = newNode(1); ` `    ``root->left = newNode(2); ` `    ``root->right = newNode(3); ` `    ``root->left->left = newNode(4); ` `    ``root->left->right = newNode(5); ` `    ``root->right->right = newNode(6); ` `    ``string str = ``""``; ` `    ``treeToString(root, str); ` `    ``cout << str; ` `} `

## Java

 `// Java program to construct string from binary tree  ` `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;  ` `};  ` `static` `String str; ` ` `  `/* 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);  ` `}  ` ` `  `// Function to construct string from binary tree  ` `static` `void` `treeToString(Node root)  ` `{  ` `    ``// bases case  ` `    ``if` `(root == ``null``)  ` `        ``return``;  ` ` `  `    ``// push the root data as character  ` `    ``str += (Character.valueOf((``char``)  ` `           ``(root.data + ``'0'``)));  ` ` `  `    ``// if leaf node, then return  ` `    ``if` `(root.left == ``null` `&& root.right == ``null``)  ` `        ``return``;  ` ` `  `    ``// for left subtree  ` `    ``str += (``'('``);  ` `    ``treeToString(root.left);  ` `    ``str += (``')'``);  ` ` `  `    ``// only if right child is present to  ` `    ``// avoid extra parenthesis  ` `    ``if` `(root.right != ``null``)  ` `    ``{  ` `        ``str += (``'('``);  ` `        ``treeToString(root.right);  ` `        ``str += (``')'``);  ` `    ``}  ` `}  ` ` `  `// Driver Code  ` `public` `static` `void` `main(String[] args)  ` `{ ` `     `  `    ``/* Let us construct below tree  ` `             ``1  ` `            ``/ \  ` `            ``2 3  ` `            ``/ \ \  ` `            ``4 5 6 */` `    ``Node root = newNode(``1``);  ` `    ``root.left = newNode(``2``);  ` `    ``root.right = newNode(``3``);  ` `    ``root.left.left = newNode(``4``);  ` `    ``root.left.right = newNode(``5``);  ` `    ``root.right.right = newNode(``6``);  ` `    ``str = ``""``;  ` `    ``treeToString(root);  ` `    ``System.out.println(str); ` `} ` `}  ` ` `  `// This code is contributed by 29AjayKumar `

## C#

 `// C# program to construct string from binary tree  ` `using` `System; ` `     `  `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;  ` `};  ` `static` `String str; ` ` `  `/* 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);  ` `}  ` ` `  `// Function to construct string from binary tree  ` `static` `void` `treeToString(Node root)  ` `{  ` `    ``// bases case  ` `    ``if` `(root == ``null``)  ` `        ``return``;  ` ` `  `    ``// push the root data as character  ` `    ``str += (``char``)(root.data + ``'0'``);  ` ` `  `    ``// if leaf node, then return  ` `    ``if` `(root.left == ``null` `&& root.right == ``null``)  ` `        ``return``;  ` ` `  `    ``// for left subtree  ` `    ``str += (``'('``);  ` `    ``treeToString(root.left);  ` `    ``str += (``')'``);  ` ` `  `    ``// only if right child is present to  ` `    ``// avoid extra parenthesis  ` `    ``if` `(root.right != ``null``)  ` `    ``{  ` `        ``str += (``'('``);  ` `        ``treeToString(root.right);  ` `        ``str += (``')'``);  ` `    ``}  ` `}  ` ` `  `// Driver Code  ` `public` `static` `void` `Main(String[] args)  ` `{ ` `     `  `    ``/* Let us construct below tree  ` `            ``1  ` `            ``/ \  ` `            ``2 3  ` `            ``/ \ \  ` `            ``4 5 6 */` `    ``Node root = newNode(1);  ` `    ``root.left = newNode(2);  ` `    ``root.right = newNode(3);  ` `    ``root.left.left = newNode(4);  ` `    ``root.left.right = newNode(5);  ` `    ``root.right.right = newNode(6);  ` `    ``str = ``""``;  ` `    ``treeToString(root);  ` `    ``Console.WriteLine(str); ` `} ` `}  ` ` `  `// This code is contributed by Princi Singh `

Output:

```1(2(4)(5))(3()(6))
```

Time complexity : O(n) The preorder traversal is done over the n nodes.
Space complexity : O(n). The depth of the recursion tree can go upto n in case of a skewed tree.

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : 29AjayKumar, princi singh

Article Tags :
Practice Tags :

2

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.