Binary tree to string with brackets

Last Updated : 23 Oct, 2024

Construct a string consisting of parenthesis and integers from a binary tree using the preorder traversing method. 
The null node needs to be represented by empty parenthesis pair “()”. Remove 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:

binary-tree-to-string-with-brackets

Output: "1(2(4)(5))(3)"
Explanation: Originally it needs to be "1(2(4)(5))(3()())", but we need to remove all the unnecessary empty parenthesis pairs. So, it will be "1(2(4)(5))(3)".

binary-tree-to-string-with-brackets-2

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

Approach:

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 remove the unnecessary braces. We print the current node and call 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, 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. 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. 

Below is the implementation of above approach:

C++ 
// C++ Program to convert Binary tree
// to string with brackets

#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node *left, *right;

    Node(int val) {
        data = val;
        left = nullptr;
      	right = nullptr;
    }
};

// Function to construct string from binary tree
void treeToString(Node* root, string& str) {
    
    if (root == nullptr)
        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(')');
    }
}

int main() {
  
    // Let us construct below tree
    //          1
    //         / \
    //        2   3
    //       / \   \
    //      4   5   6    
  
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->left = new Node(4);
    root->left->right = new Node(5);
    root->right->right = new Node(6);

    string str = "";
    treeToString(root, str);
    cout << str;
}
Java 
// Java Program to convert Binary tree
// to string with brackets

class Node {
    int data;
    Node left, right;

    Node(int val) {
        data = val;
        left = null;
        right = null;
    }
}

class GfG {
  
    // Function to construct string from binary tree
    static void treeToString(Node root, StringBuilder str) {
      
        // base case
        if (root == null) {
            return;
        }

        // push the root data as character
        str.append(root.data);

        // if leaf node, then return
        if (root.left == null && root.right == null) {
            return;
        }

        // for left subtree
        str.append('(');
        treeToString(root.left, str);
        str.append(')');

        // only if right child is present to 
        // avoid extra parenthesis
        if (root.right != null) {
            str.append('(');
            treeToString(root.right, str);
            str.append(')');
        }
    }

    public static void main(String[] args) {
      
        // Let us construct below tree
        //          1
        //         / \
        //        2   3
        //       / \   \
        //      4   5   6    

        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.right = new Node(6);

        StringBuilder str = new StringBuilder();
        treeToString(root, str);
        System.out.println(str.toString());
    }
}
Python 
# Python Program to convert Binary tree
# to string with brackets

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

# Function to construct string from binary tree
def treeToString(root, result):
  
    # base case
    if root is None:
        return

    # push the root data as character
    result.append(str(root.data))

    # if leaf node, then return
    if not root.left and not root.right:
        return

    # for left subtree
    result.append('(')
    treeToString(root.left, result)
    result.append(')')

    # only if right child is present to 
    # avoid extra parenthesis
    if root.right:
        result.append('(')
        treeToString(root.right, result)
        result.append(')')

if __name__ == "__main__":

    # Let us construct below tree
    #          1
    #         / \
    #        2   3
    #       / \   \
    #      4   5   6    

    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.left.right = Node(5)
    root.right.right = Node(6)

    result = []
    treeToString(root, result)
    print("".join(result))
C# 
// C# Program to convert Binary tree to 
// string with brackets

using System;
using System.Text;

class Node {
    public int data;
    public Node left, right;

    public Node(int val) {
        data = val;
        left = null;
        right = null;
    }
}

class GfG {
  
    // Function to construct string from binary tree
    static void TreeToString(Node root, StringBuilder str) {
      
        // base case
        if (root == null)
            return;

        // push the root data as character
        str.Append(root.data);

        // if leaf node, then return
        if (root.left == null && root.right == null)
            return;

        // for left subtree
        str.Append('(');
        TreeToString(root.left, str);
        str.Append(')');

        // only if right child is present to 
        // avoid extra parenthesis
        if (root.right != null) {
            str.Append('(');
            TreeToString(root.right, str);
            str.Append(')');
        }
    }

    static void Main(string[] args) {
      
        // Let us construct below tree
        //          1
        //         / \
        //        2   3
        //       / \   \
        //      4   5   6    

        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.right = new Node(6);

        StringBuilder str = new StringBuilder();
        TreeToString(root, str);
        Console.WriteLine(str.ToString());
    }
}
JavaScript 
// JavaScript Program to convert Binary 
// tree to string with brackets

class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

// Function to construct string from binary tree
function treeToString(root, result) {

    // base case
    if (root === null)
        return;

    // push the root data as character
    result.push(root.data.toString());

    // if leaf node, then return
    if (!root.left && !root.right)
        return;

    // for left subtree
    result.push('(');
    treeToString(root.left, result);
    result.push(')');

    // only if right child is present to 
    // avoid extra parenthesis
    if (root.right) {
        result.push('(');
        treeToString(root.right, result);
        result.push(')');
    }
}

// Let us construct below tree
//          1
//         / \
//        2   3
//       / \   \
//      4   5   6    

let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.right = new Node(6);

let result = [];
treeToString(root, result);
console.log(result.join(''));

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

Time complexity: O(n) where n is the number of nodes in Binary Tree. 
Auxiliary Space: O(h), where h is height of tree.

Comment
Article Tags:
Misc
Strings
Tree
DSA

Explore