# Convert Ternary Expression to a Binary Tree

Given a string that contains ternary expressions. The expressions may be nested, task is convert the given ternary expression to a binary Tree.

Examples:

`Input :  string expression =   a?b:c Output :        a              /  \             b    cInput : expression =  a?b?c:d:eOutput :     a           /  \          b    e        /  \       c    d`

Idea is that we traverse a string make first character as root and do following step recursively .

1. If we see Symbol ‘?’
• then we add next character as the left child of root.
2. If we see Symbol ‘:’
• then we add it as the right child of current root.

do this process until we traverse all element of “String”.

Below is the implementation of above idea

## C++

 `// C++ program to convert a ternary expression to ``// a tree. ``#include ``using` `namespace` `std; `` ` `// tree structure ``struct` `Node ``{ ``    ``char` `data; ``    ``Node *left, *right; ``}; `` ` `// function create a new node ``Node *newNode(``char` `Data) ``{ ``    ``Node *new_node = ``new` `Node; ``    ``new_node->data = Data; ``    ``new_node->left = new_node->right = NULL; ``    ``return` `new_node; ``} `` ` `// Function to convert Ternary Expression to a Binary ``// Tree. It return the root of tree ``// Notice that we pass index i by reference because we  ``// want to skip the characters in the subtree ``Node *convertExpression(string str, ``int` `& i) ``{ ``    ``// store current character of expression_string  ``    ``// [ 'a' to 'z']  ``    ``Node * root =newNode(str[i]); `` ` `    ``//If it was last character return ``    ``//Base Case ``    ``if``(i==str.length()-1) ``return` `root; `` ` `    ``// Move ahead in str  ``    ``i++; ``    ``//If the next character is '?'.Then there will be subtree for the current node ``    ``if``(str[i]==``'?'``) ``    ``{ ``        ``//skip the '?' ``        ``i++; `` ` `        ``// construct the left subtree ``        ``// Notice after the below recursive call i will point to ':'  ``        ``// just before the right child of current node since we pass i by reference ``        ``root->left = convertExpression(str,i); ``         ` `        ``//skip the ':' character ``        ``i++; `` ` `        ``//construct the right subtree ``        ``root->right = convertExpression(str,i); ``        ``return` `root; ``    ``} ``    ``//If the next character is not '?' no subtree just return it ``    ``else` `return` `root; ``} `` ` `// function print tree ``void` `printTree( Node *root) ``{ ``    ``if` `(!root) ``        ``return` `; ``    ``cout << root->data <<``" "``; ``    ``printTree(root->left); ``    ``printTree(root->right); ``} `` ` `// Driver program to test above function ``int` `main() ``{ ``    ``string expression = ``"a?b?c:d:e"``; ``    ``int` `i=0; ``    ``Node *root = convertExpression(expression, i); ``    ``printTree(root) ; ``    ``return` `0; ``} `

## Java

 `// Java program to convert a ternary  ``// expression to a tree. ``import` `java.util.Queue; ``import` `java.util.LinkedList; ``  ` `// Class to represent Tree node  ``class` `Node  ``{ ``    ``char` `data; ``    ``Node left, right; ``  ` `    ``public` `Node(``char` `item)  ``    ``{ ``        ``data = item; ``        ``left = ``null``; ``        ``right = ``null``; ``    ``} ``} ``  ` `// Class to convert a ternary expression to a Tree  ``class` `BinaryTree  ``{ ``    ``// Function to convert Ternary Expression to a Binary ``    ``// Tree. It return the root of tree ``    ``Node convertExpression(``char``[] expression, ``int` `i) ``    ``{ ``        ``// Base case ``        ``if` `(i >= expression.length) ``            ``return` `null``; ``      ` `        ``// store current character of expression_string ``        ``// [ 'a' to 'z'] ``        ``Node root = ``new` `Node(expression[i]); ``      ` `        ``// Move ahead in str ``        ``++i; ``      ` `        ``// if current character of ternary expression is '?' ``        ``// then we add next character as a left child of ``        ``// current node ``        ``if` `(i < expression.length && expression[i]==``'?'``) ``            ``root.left = convertExpression(expression, i+``1``); ``      ` `        ``// else we have to add it as a right child of ``        ``// current node expression.at(0) == ':' ``        ``else` `if` `(i < expression.length) ``            ``root.right = convertExpression(expression, i+``1``); ``      ` `        ``return` `root; ``    ``} ``     ` `    ``// function print tree ``    ``public` `void` `printTree( Node root) ``    ``{ ``        ``if` `(root == ``null``) ``            ``return``; ``                 ` `        ``System.out.print(root.data +``" "``); ``        ``printTree(root.left); ``        ``printTree(root.right); ``    ``} ``     ` `// Driver program to test above function ``    ``public` `static` `void` `main(String args[])  ``    ``{ ``        ``String exp = ``"a?b?c:d:e"``; ``        ``BinaryTree tree = ``new` `BinaryTree(); ``        ``char``[] expression=exp.toCharArray();  ``        ``Node root = tree.convertExpression(expression, ``0``); ``        ``tree.printTree(root) ; ``    ``} ``} `` ` `/* This code is contributed by Mr. Somesh Awasthi */`

## Python3

 `# Class to define a node  ``# structure of the tree ``class` `Node: ``    ``def` `__init__(``self``, key): ``        ``self``.data ``=` `key ``        ``self``.left ``=` `None``        ``self``.right ``=` `None`` ` `# Function to convert ternary  ``# expression to a Binary tree ``# It returns the root node  ``# of the tree ``def` `convert_expression(expression, i): ``    ``if` `i >``=` `len``(expression): ``        ``return` `None`` ` `    ``# Create a new node object ``    ``# for the expression at ``    ``# ith index ``    ``root ``=` `Node(expression[i]) `` ` `    ``i ``+``=` `1`` ` `    ``# if current character of  ``    ``# ternary expression is '?' ``    ``# then we add next character  ``    ``# as a left child of ``    ``# current node ``    ``if` `(i < ``len``(expression) ``and` `                ``expression[i] ``is` `"?"``): ``        ``root.left ``=` `convert_expression(expression, i ``+` `1``) ``         ` `    ``# else we have to add it  ``    ``# as a right child of ``    ``# current node expression[0] == ':' ``    ``elif` `i < ``len``(expression): ``        ``root.right ``=` `convert_expression(expression, i ``+` `1``) ``    ``return` `root `` ` `# Function to print the tree ``# in a pre-order traversal pattern ``def` `print_tree(root): ``    ``if` `not` `root: ``        ``return``    ``print``(root.data, end``=``' '``) ``    ``print_tree(root.left) ``    ``print_tree(root.right) `` ` `# Driver Code ``if` `__name__ ``=``=` `"__main__"``: ``    ``string_expression ``=` `"a?b?c:d:e"``    ``root_node ``=` `convert_expression(string_expression, ``0``) ``    ``print_tree(root_node) `` ` `# This code is contributed ``# by Kanav Malhotra `

## C#

 `// C# program to convert a ternary  ``// expression to a tree.  ``using` `System; `` ` `// Class to represent Tree node  ``public` `class` `Node ``{ ``    ``public` `char` `data; ``    ``public` `Node left, right; `` ` `    ``public` `Node(``char` `item) ``    ``{ ``        ``data = item; ``        ``left = ``null``; ``        ``right = ``null``; ``    ``} ``} `` ` `// Class to convert a ternary  ``// expression to a Tree  ``public` `class` `BinaryTree ``{ ``    ``// Function to convert Ternary Expression  ``    ``// to a Binary Tree. It return the root of tree  ``    ``public` `virtual` `Node convertExpression(``char``[] expression, ``                                          ``int` `i) ``    ``{ ``        ``// Base case  ``        ``if` `(i >= expression.Length) ``        ``{ ``            ``return` `null``; ``        ``} `` ` `        ``// store current character of  ``        ``// expression_string [ 'a' to 'z']  ``        ``Node root = ``new` `Node(expression[i]); `` ` `        ``// Move ahead in str  ``        ``++i; `` ` `        ``// if current character of ternary expression  ``        ``// is '?' then we add next character as a  ``        ``// left child of current node  ``        ``if` `(i < expression.Length && expression[i] == ``'?'``) ``        ``{ ``            ``root.left = convertExpression(expression, i + 1); ``        ``} `` ` `        ``// else we have to add it as a right child  ``        ``// of current node expression.at(0) == ':'  ``        ``else` `if` `(i < expression.Length) ``        ``{ ``            ``root.right = convertExpression(expression, i + 1); ``        ``} `` ` `        ``return` `root; ``    ``} `` ` `    ``// function print tree  ``    ``public` `virtual` `void` `printTree(Node root) ``    ``{ ``        ``if` `(root == ``null``) ``        ``{ ``            ``return``; ``        ``} `` ` `        ``Console.Write(root.data + ``" "``); ``        ``printTree(root.left); ``        ``printTree(root.right); ``    ``} `` ` `// Driver Code ``public` `static` `void` `Main(``string``[] args) ``{ ``    ``string` `exp = ``"a?b?c:d:e"``; ``    ``BinaryTree tree = ``new` `BinaryTree(); ``    ``char``[] expression = exp.ToCharArray(); ``    ``Node root = tree.convertExpression(expression, 0); ``    ``tree.printTree(root); ``} ``} `` ` `// This code is contributed by Shrikant13 `

## Javascript

 ``

Output
```a b c d e

```

Time Complexity : O(n) [ here n is length of String ]
Auxiliary Space: O(n)

### Approach for Converting Ternary Expression to Binary Tree.

• The algorithm uses a recursive approach to build the tree in a top-down manner.
• It starts with creating a new node for the current character at the current index.
• If the next character is a ‘?’, it means that the current node needs a left child. So, the algorithm calls itself recursively with the next index to create the left child of the current node.
• If the next character is a ‘:’, it means that the current node needs a right child. So, the algorithm calls itself recursively with the next index to create the right child of the current node.
• Finally, the algorithm returns the root node of the binary tree.

Here is the implementation of above approach:-

## C++

 `#include ``using` `namespace` `std; `` ` `class` `Node { ``public``: ``    ``char` `val; ``    ``Node *left, *right; ``    ``Node(``char` `v) : val(v), left(nullptr), right(nullptr) {} ``}; `` ` `Node* ternaryToTree(string ``exp``) { ``    ``if` `(``exp``.empty()) ``return` `nullptr; ``    ``Node *root = ``new` `Node(``exp``[0]); ``    ``stack st; ``    ``st.push(root); ``    ``for` `(``int` `i = 1; i < ``exp``.size(); i += 2) { ``        ``Node *cur = st.top(); st.pop(); ``        ``if` `(``exp``[i] == ``'?'``) { ``            ``cur->left = ``new` `Node(``exp``[i+1]); ``            ``st.push(cur); ``            ``st.push(cur->left); ``        ``} ``else` `{ ``            ``cur->right = ``new` `Node(``exp``[i+1]); ``            ``st.push(cur->right); ``        ``} ``    ``} ``    ``return` `root; ``} `` ` `void` `printTree(Node* root) { ``    ``if` `(!root) ``return``; ``    ``cout << root->val << ``" "``; ``    ``printTree(root->left); ``    ``printTree(root->right); ``} `` ` `int` `main() { ``    ``string ``exp` `= ``"a?b?c:d:e"``; ``    ``Node *root = ternaryToTree(``exp``); ``    ``printTree(root); ``    ``return` `0; ``} `

## Java

 `import` `java.util.*; `` ` `class` `Node { ``    ``char` `val; ``    ``Node left, right; ``    ``public` `Node(``char` `v) { val = v; } ``} `` ` `class` `Solution { ``    ``public` `static` `Node ternaryToTree(String exp) { ``        ``if` `(exp == ``null` `|| exp.length() == ``0``) ``return` `null``; ``        ``Node root = ``new` `Node(exp.charAt(``0``)); ``        ``Stack st = ``new` `Stack<>(); ``        ``st.push(root); ``        ``for` `(``int` `i = ``1``; i < exp.length(); i += ``2``) { ``            ``Node cur = st.pop(); ``            ``if` `(exp.charAt(i) == ``'?'``) { ``                ``cur.left = ``new` `Node(exp.charAt(i+``1``)); ``                ``st.push(cur); ``                ``st.push(cur.left); ``            ``} ``else` `{ ``                ``cur.right = ``new` `Node(exp.charAt(i+``1``)); ``                ``st.push(cur.right); ``            ``} ``        ``} ``        ``return` `root; ``    ``} `` ` `    ``public` `static` `void` `printTree(Node root) { ``        ``if` `(root == ``null``) ``return``; ``        ``System.out.print(root.val + ``" "``); ``        ``printTree(root.left); ``        ``printTree(root.right); ``    ``} `` ` `    ``public` `static` `void` `main(String[] args) { ``        ``String exp = ``"a?b?c:d:e"``; ``        ``Node root = ternaryToTree(exp); ``        ``printTree(root); ``    ``} ``} `

## Python3

 `class` `Node: ``    ``def` `__init__(``self``, val): ``        ``self``.val ``=` `val ``        ``self``.left ``=` `None``        ``self``.right ``=` `None`` ` `def` `ternary_to_tree(exp): ``    ``if` `not` `exp: ``        ``return` `None``    ``root ``=` `Node(exp[``0``]) ``    ``stack ``=` `[root] ``    ``for` `i ``in` `range``(``1``, ``len``(exp)): ``        ``if` `exp[i] ``=``=` `'?'``: ``            ``stack[``-``1``].left ``=` `Node(exp[i``+``1``]) ``            ``stack.append(stack[``-``1``].left) ``        ``elif` `exp[i] ``=``=` `':'``: ``            ``stack.pop() ``            ``while` `stack[``-``1``].right: ``                ``stack.pop() ``            ``stack[``-``1``].right ``=` `Node(exp[i``+``1``]) ``            ``stack.append(stack[``-``1``].right) ``    ``return` `root `` ` `def` `print_tree(root): ``    ``if` `not` `root: ``        ``return``    ``print``(root.val, end``=``' '``) ``    ``print_tree(root.left) ``    ``print_tree(root.right) `` ` `if` `__name__ ``=``=` `"__main__"``: ``    ``exp ``=` `"a?b?c:d:e"``    ``root ``=` `ternary_to_tree(exp) ``    ``print_tree(root) `

## C#

 `using` `System; ``using` `System.Collections.Generic; `` ` `class` `Node{ ``    ``public` `char` `val; ``    ``public` `Node left, right; ``    ``public` `Node(``char` `v) { val = v; } ``} `` ` `class` `Solution{ ``    ``// Function to convert a ternary expression to a tree ``    ``public` `static` `Node ternaryToTree(``string` `exp){ ``        ``if` `(exp == ``null` `|| exp.Length == 0) ``return` `null``; ``        ``Node root = ``new` `Node(exp[0]); ``// Create the root node ``        ``Stack st = ``new` `Stack(); ``// Stack to track nodes ``        ``st.Push(root); ``// Push root to the stack ``        ``for` `(``int` `i = 1; i < exp.Length; i += 2){ ``            ``Node cur = st.Pop(); ``// Pop the top node from the stack ``            ``if` `(exp[i] == ``'?'``){ ``                ``cur.left = ``new` `Node(exp[i + 1]); ``// Create a left child node ``                ``st.Push(cur); ``// Push the current node back to the stack ``                ``st.Push(cur.left); ``// Push the left child node to the stack ``            ``} ``            ``else``{ ``                ``cur.right = ``new` `Node(exp[i + 1]); ``// Create a right child node ``                ``st.Push(cur.right); ``// Push the right child node to the stack ``            ``} ``        ``} ``        ``return` `root; ``// Return the root node of the tree ``    ``} `` ` `    ``// Function to print the tree in pre-order traversal ``    ``public` `static` `void` `printTree(Node root){ ``        ``if` `(root == ``null``) ``return``; ``        ``Console.Write(root.val + ``" "``); ``// Print the current node ``        ``printTree(root.left); ``// Recursively print the left subtree ``        ``printTree(root.right); ``// Recursively print the right subtree ``    ``} `` ` `    ``public` `static` `void` `Main(``string``[] args){ ``        ``string` `exp = ``"a?b?c:d:e"``; ``        ``Node root = ternaryToTree(exp); ``        ``printTree(root); ``    ``} ``} `` ` `// THIS CODE IS CONTRIBUTED BY CHANDAN AGARWAL`

## Javascript

 `class Node { ``  ``constructor(val) { ``    ``this``.val = val; ``    ``this``.left = ``null``; ``    ``this``.right = ``null``; ``  ``} ``} `` ` `let i = 0; `` ` `function` `convertExpression(expression) { ``  ``if` `(!expression || i >= expression.length) { ``    ``return` `null``; ``  ``} `` ` `  ``const root = ``new` `Node(expression[i]); ``  ``i++; `` ` `  ``if` `(i < expression.length && expression[i] === ``"?"``) { ``    ``i++; ``    ``root.left = convertExpression(expression); ``  ``} `` ` `  ``if` `(i < expression.length && expression[i] === ``":"``) { ``    ``i++; ``    ``root.right = convertExpression(expression); ``  ``} `` ` `  ``return` `root; ``} `` ` `function` `printTree(root) { ``  ``if` `(!root) { ``    ``return``; ``  ``} `` ` `  ``console.log(root.val + ``" "``); ``  ``printTree(root.left); ``  ``printTree(root.right); ``} `` ` `const stringExpression = ``"a?b?c:d:e"``; ``const rootNode = convertExpression(stringExpression); ``printTree(rootNode); `

Output
```a b c d e

```

Time complexity: O(n) – Since we visit each character of the expression exactly once.

Space complexity: O(n) – Since in the worst case, the recursion stack can grow to the height of the tree, which can be O(n) if the ternary expression is a degenerate tree (a long chain of ‘?’). Additionally, we store O(n) nodes in the binary tree.

Previous
Next