# 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.

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

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next