# Convert a Binary Tree to Threaded binary tree | Set 2 (Efficient)

Idea of Threaded Binary Tree is to make inorder traversal faster and do it without stack and without recursion. In a simple threaded binary tree, the NULL right pointers are used to store inorder successor. Where-ever a right pointer is NULL, it is used to store inorder successor.

Following diagram shows an example Single Threaded Binary Tree. The dotted lines represent threads. Following is structure of a single-threaded binary tree.

 `struct` `Node ` `{ ` `    ``int` `key; ` `    ``Node *left, *right; ` ` `  `    ``// Used to indicate whether the right pointer is a normal right  ` `    ``// pointer or a pointer to inorder successor. ` `    ``bool` `isThreaded;  ` `};`

How to convert a Given Binary Tree to Threaded Binary Tree?
We have discussed a Queue-based solution here. In this post, space-efficient solution is discussed that doesn’t require a queue.

The idea is based on the fact that we link from inorder predecessor to a node. We link those inorder predecessor which lie in subtree of node. So we find inorder predecessor of a node if its left is not NULL. Inorder predecessor of a node (whose left is NULL) is a rightmost node in the left child. Once we find the predecessor, we link a thread from it to the current node.
Following is the implementation of the above idea.

## C++

 `/* C++ program to convert a Binary Tree to ` `    ``Threaded Tree */` `#include ` `using` `namespace` `std; ` ` `  `/* Structure of a node in threaded binary tree */` `struct` `Node ` `{ ` `    ``int` `key; ` `    ``Node *left, *right; ` ` `  `    ``// Used to indicate whether the right pointer ` `    ``// is a normal right pointer or a pointer ` `    ``// to inorder successor. ` `    ``bool` `isThreaded; ` `}; ` ` `  `// Converts tree with given root to threaded ` `// binary tree. ` `// This function returns rightmost child of ` `// root. ` `Node *createThreaded(Node *root) ` `{ ` `    ``// Base cases : Tree is empty or has single ` `    ``//              node ` `    ``if` `(root == NULL) ` `        ``return` `NULL; ` `    ``if` `(root->left == NULL && ` `        ``root->right == NULL) ` `        ``return` `root; ` ` `  `    ``// Find predecessor if it exists ` `    ``if` `(root->left != NULL) ` `    ``{ ` `        ``// Find predecessor of root (Rightmost ` `        ``// child in left subtree) ` `        ``Node* l = createThreaded(root->left); ` ` `  `        ``// Link a thread from predecessor to ` `        ``// root. ` `        ``l->right = root; ` `        ``l->isThreaded = ``true``; ` `    ``} ` ` `  `    ``// If current node is rightmost child ` `    ``if` `(root->right == NULL) ` `        ``return` `root; ` ` `  `    ``// Recur for right subtree. ` `    ``return` `createThreaded(root->right); ` `} ` ` `  `// A utility function to find leftmost node ` `// in a binary tree rooted with 'root'. ` `// This function is used in inOrder() ` `Node *leftMost(Node *root) ` `{ ` `    ``while` `(root != NULL && root->left != NULL) ` `        ``root = root->left; ` `    ``return` `root; ` `} ` ` `  `// Function to do inorder traversal of a threadded ` `// binary tree ` `void` `inOrder(Node *root) ` `{ ` `    ``if` `(root == NULL) ``return``; ` ` `  `    ``// Find the leftmost node in Binary Tree ` `    ``Node *cur = leftMost(root); ` ` `  `    ``while` `(cur != NULL) ` `    ``{ ` `        ``cout << cur->key << ``" "``; ` ` `  `        ``// If this Node is a thread Node, then go to ` `        ``// inorder successor ` `        ``if` `(cur->isThreaded) ` `            ``cur = cur->right; ` ` `  `        ``else` `// Else go to the leftmost child in right subtree ` `            ``cur = leftMost(cur->right); ` `    ``} ` `} ` ` `  `// A utility function to create a new node ` `Node *newNode(``int` `key) ` `{ ` `    ``Node *temp = ``new` `Node; ` `    ``temp->left = temp->right = NULL; ` `    ``temp->key = key; ` `    ``return` `temp; ` `} ` ` `  `// Driver program to test above functions ` `int` `main() ` `{ ` `    ``/*       1 ` `            ``/ \ ` `           ``2   3 ` `          ``/ \ / \ ` `         ``4  5 6  7   */` `    ``Node *root = newNode(1); ` `    ``root->left = newNode(2); ` `    ``root->right = newNode(3); ` `    ``root->left->left = newNode(4); ` `    ``root->left->right = newNode(5); ` `    ``root->right->left = newNode(6); ` `    ``root->right->right = newNode(7); ` ` `  `    ``createThreaded(root); ` ` `  `    ``cout << ``"Inorder traversal of created "` `            ``"threaded tree is\n"``; ` `    ``inOrder(root); ` `    ``return` `0; ` `} `

## Java

 `/* Java program to convert a Binary Tree to  ` `    ``Threaded Tree */` `import` `java.util.*; ` `class` `solution ` `{ ` `  `  `   `  `/* structure of a node in threaded binary tree */` `static` `class` `Node  ` `{  ` `    ``int` `key;  ` `    ``Node left, right;  ` `   `  `    ``// Used to indicate whether the right pointer  ` `    ``// is a normal right pointer or a pointer  ` `    ``// to inorder successor.  ` `    ``boolean` `isThreaded;  ` `};  ` `   `  `// Converts tree with given root to threaded  ` `// binary tree.  ` `// This function returns rightmost child of  ` `// root.  ` `static` `Node createThreaded(Node root)  ` `{  ` `    ``// Base cases : Tree is empty or has single  ` `    ``//              node  ` `    ``if` `(root == ``null``)  ` `        ``return` `null``;  ` `    ``if` `(root.left == ``null` `&&  ` `        ``root.right == ``null``)  ` `        ``return` `root;  ` `   `  `    ``// Find predecessor if it exists  ` `    ``if` `(root.left != ``null``)  ` `    ``{  ` `        ``// Find predecessor of root (Rightmost  ` `        ``// child in left subtree)  ` `        ``Node l = createThreaded(root.left);  ` `   `  `        ``// Link a thread from predecessor to  ` `        ``// root.  ` `        ``l.right = root;  ` `        ``l.isThreaded = ``true``;  ` `    ``}  ` `   `  `    ``// If current node is rightmost child  ` `    ``if` `(root.right == ``null``)  ` `        ``return` `root;  ` `   `  `    ``// Recur for right subtree.  ` `    ``return` `createThreaded(root.right);  ` `}  ` `   `  `// A utility function to find leftmost node  ` `// in a binary tree rooted with 'root'.  ` `// This function is used in inOrder()  ` `static` `Node leftMost(Node root)  ` `{  ` `    ``while` `(root != ``null` `&& root.left != ``null``)  ` `        ``root = root.left;  ` `    ``return` `root;  ` `}  ` `   `  `// Function to do inorder traversal of a threadded  ` `// binary tree  ` `static` `void` `inOrder(Node root)  ` `{  ` `    ``if` `(root == ``null``) ``return``;  ` `   `  `    ``// Find the leftmost node in Binary Tree  ` `    ``Node cur = leftMost(root);  ` `   `  `    ``while` `(cur != ``null``)  ` `    ``{  ` `        ``System.out.print(cur.key + ``" "``);  ` `   `  `        ``// If this Node is a thread Node, then go to  ` `        ``// inorder successor  ` `        ``if` `(cur.isThreaded)  ` `            ``cur = cur.right;  ` `   `  `        ``else` `// Else go to the leftmost child in right subtree  ` `            ``cur = leftMost(cur.right);  ` `    ``}  ` `}  ` `   `  `// A utility function to create a new node  ` `static` `Node newNode(``int` `key)  ` `{  ` `    ``Node temp = ``new` `Node();  ` `    ``temp.left = temp.right = ``null``;  ` `    ``temp.key = key;  ` `    ``return` `temp;  ` `}  ` `   `  `// Driver program to test above functions  ` `public` `static` `void` `main(String args[]) ` `{  ` `   ``/*       1  ` `            ``/ \  ` `           ``2   3  ` `          ``/ \ / \  ` `         ``4  5 6  7   */` `    ``Node root = newNode(``1``);  ` `    ``root.left = newNode(``2``);  ` `    ``root.right = newNode(``3``);  ` `    ``root.left.left = newNode(``4``);  ` `    ``root.left.right = newNode(``5``);  ` `    ``root.right.left = newNode(``6``);  ` `    ``root.right.right = newNode(``7``);  ` `   `  `    ``createThreaded(root);  ` `   `  `    ``System.out.println(``"Inorder traversal of created "``+``"threaded tree is\n"``);  ` `    ``inOrder(root);   ` `}  ` `} ` `//contributed by Arnab Kundu `

## Python3

 `# Python3 program to convert a Binary Tree to  ` `# Threaded Tree  ` ` `  `# A utility function to create a new node  ` `class` `newNode: ` `    ``def` `__init__(``self``, key): ` `        ``self``.left ``=` `self``.right ``=` `None` `        ``self``.key ``=` `key  ` `        ``self``.isThreaded ``=` `None` `         `  `# Converts tree with given root to threaded  ` `# binary tree.  ` `# This function returns rightmost child of  ` `# root.  ` `def` `createThreaded(root): ` `     `  `    ``# Base cases : Tree is empty or has   ` `    ``#               single node  ` `    ``if` `root ``=``=` `None``:  ` `        ``return` `None` `    ``if` `root.left ``=``=` `None` `and` `root.right ``=``=` `None``:  ` `        ``return` `root  ` ` `  `    ``# Find predecessor if it exists  ` `    ``if` `root.left !``=` `None``: ` `         `  `        ``# Find predecessor of root (Rightmost  ` `        ``# child in left subtree)  ` `        ``l ``=` `createThreaded(root.left)  ` ` `  `        ``# Link a thread from predecessor  ` `        ``# to root.  ` `        ``l.right ``=` `root  ` `        ``l.isThreaded ``=` `True` ` `  `    ``# If current node is rightmost child  ` `    ``if` `root.right ``=``=` `None``:  ` `        ``return` `root  ` ` `  `    ``# Recur for right subtree.  ` `    ``return` `createThreaded(root.right) ` ` `  `# A utility function to find leftmost node  ` `# in a binary tree rooted with 'root'.  ` `# This function is used in inOrder()  ` `def` `leftMost(root): ` `    ``while` `root !``=` `None` `and` `root.left !``=` `None``:  ` `        ``root ``=` `root.left  ` `    ``return` `root ` ` `  `# Function to do inorder traversal of a  ` `# threaded binary tree  ` `def` `inOrder(root): ` `    ``if` `root ``=``=` `None``: ` `        ``return` ` `  `    ``# Find the leftmost node in Binary Tree  ` `    ``cur ``=` `leftMost(root)  ` ` `  `    ``while` `cur !``=` `None``: ` `        ``print``(cur.key, end ``=` `" "``)  ` ` `  `        ``# If this Node is a thread Node, then ` `        ``# go to inorder successor  ` `        ``if` `cur.isThreaded:  ` `            ``cur ``=` `cur.right  ` ` `  `        ``else``: ``# Else go to the leftmost child ` `              ``# in right subtree  ` `            ``cur ``=` `leftMost(cur.right) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` `     `  `    ``#         1  ` `    ``#     / \  ` `    ``#     2 3  ` `    ``#     / \ / \  ` `    ``#     4 5 6 7  ` `    ``root ``=` `newNode(``1``)  ` `    ``root.left ``=` `newNode(``2``)  ` `    ``root.right ``=` `newNode(``3``)  ` `    ``root.left.left ``=` `newNode(``4``)  ` `    ``root.left.right ``=` `newNode(``5``)  ` `    ``root.right.left ``=` `newNode(``6``)  ` `    ``root.right.right ``=` `newNode(``7``)  ` ` `  `    ``createThreaded(root)  ` ` `  `    ``print``(``"Inorder traversal of created"``, ` `                      ``"threaded tree is"``)  ` `    ``inOrder(root) ` ` `  `# This code is contributed by PranchalK `

## C#

 `using` `System; ` ` `  `/* C# program to convert a Binary Tree to   ` `    ``Threaded Tree */` `public` `class` `solution ` `{ ` ` `  ` `  `/* structure of a node in threaded binary tree */` `public` `class` `Node ` `{ ` `    ``public` `int` `key; ` `    ``public` `Node left, right; ` ` `  `    ``// Used to indicate whether the right pointer   ` `    ``// is a normal right pointer or a pointer   ` `    ``// to inorder successor.   ` `    ``public` `bool` `isThreaded; ` `} ` ` `  `// Converts tree with given root to threaded   ` `// binary tree.   ` `// This function returns rightmost child of   ` `// root.   ` `public` `static` `Node createThreaded(Node root) ` `{ ` `    ``// Base cases : Tree is empty or has single   ` `    ``//              node   ` `    ``if` `(root == ``null``) ` `    ``{ ` `        ``return` `null``; ` `    ``} ` `    ``if` `(root.left == ``null` `&& root.right == ``null``) ` `    ``{ ` `        ``return` `root; ` `    ``} ` ` `  `    ``// Find predecessor if it exists   ` `    ``if` `(root.left != ``null``) ` `    ``{ ` `        ``// Find predecessor of root (Rightmost   ` `        ``// child in left subtree)   ` `        ``Node l = createThreaded(root.left); ` ` `  `        ``// Link a thread from predecessor to   ` `        ``// root.   ` `        ``l.right = root; ` `        ``l.isThreaded = ``true``; ` `    ``} ` ` `  `    ``// If current node is rightmost child   ` `    ``if` `(root.right == ``null``) ` `    ``{ ` `        ``return` `root; ` `    ``} ` ` `  `    ``// Recur for right subtree.   ` `    ``return` `createThreaded(root.right); ` `} ` ` `  `// A utility function to find leftmost node   ` `// in a binary tree rooted with 'root'.   ` `// This function is used in inOrder()   ` `public` `static` `Node leftMost(Node root) ` `{ ` `    ``while` `(root != ``null` `&& root.left != ``null``) ` `    ``{ ` `        ``root = root.left; ` `    ``} ` `    ``return` `root; ` `} ` ` `  `// Function to do inorder traversal of a threadded   ` `// binary tree   ` `public` `static` `void` `inOrder(Node root) ` `{ ` `    ``if` `(root == ``null``) ` `    ``{ ` `        ``return``; ` `    ``} ` ` `  `    ``// Find the leftmost node in Binary Tree   ` `    ``Node cur = leftMost(root); ` ` `  `    ``while` `(cur != ``null``) ` `    ``{ ` `        ``Console.Write(cur.key + ``" "``); ` ` `  `        ``// If this Node is a thread Node, then go to   ` `        ``// inorder successor   ` `        ``if` `(cur.isThreaded) ` `        ``{ ` `            ``cur = cur.right; ` `        ``} ` ` `  `        ``else` `// Else go to the leftmost child in right subtree ` `        ``{ ` `            ``cur = leftMost(cur.right); ` `        ``} ` `    ``} ` `} ` ` `  `// A utility function to create a new node   ` `public` `static` `Node newNode(``int` `key) ` `{ ` `    ``Node temp = ``new` `Node(); ` `    ``temp.left = temp.right = ``null``; ` `    ``temp.key = key; ` `    ``return` `temp; ` `} ` ` `  `// Driver program to test above functions   ` `public` `static` `void` `Main(``string``[] args) ` `{ ` `   ``/*       1   ` `            ``/ \   ` `           ``2   3   ` `          ``/ \ / \   ` `         ``4  5 6  7   */` `    ``Node root = newNode(1); ` `    ``root.left = newNode(2); ` `    ``root.right = newNode(3); ` `    ``root.left.left = newNode(4); ` `    ``root.left.right = newNode(5); ` `    ``root.right.left = newNode(6); ` `    ``root.right.right = newNode(7); ` ` `  `    ``createThreaded(root); ` ` `  `    ``Console.WriteLine(``"Inorder traversal of created "` `+ ``"threaded tree is\n"``); ` `    ``inOrder(root); ` `} ` `} ` ` `  `  ``// This code is contributed by Shrikant13 `

Output:

```Inorder traversal of created threaded tree is
4 2 5 1 6 3 7```

This algorithm works in O(n) time complexity and O(1) space other than function call stack.

This article is contributed by Gopal Agarwal. 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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

3

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