# Threaded Binary Tree | Insertion

Insertion in Binary threaded tree is similar to insertion in binary tree but we will have to adjust the threads after insertion of each element.

C representation of Binary Threaded Node:

```struct Node
{
struct Node *left, *right;
int info;

// True if left pointer points to predecessor
// in Inorder Traversal

// True if right pointer points to successor
// in Inorder Traversal
};```

In the following explanation, we have considered Binary Search Tree (BST) for insertion as insertion is defined by some rules in BSTs.

Let tmp be the newly inserted node. There can be three cases during insertion:

Case 1: Insertion in empty tree
Both left and right pointers of tmp will be set to NULL and new node becomes the root.

```root = tmp;
tmp -> left = NULL;
tmp -> right = NULL;```

Case 2: When new node inserted as the left child
After inserting the node at its proper place we have to make its left and right threads points to inorder predecessor and successor respectively. The node which was inorder successor. So the left and right threads of the new node will be-

```tmp -> left = par ->left;
tmp -> right = par;```

Before insertion, the left pointer of parent was a thread, but after insertion it will be a link pointing to the new node.

```par -> lthread = false;
par -> left = temp;```

Following example show a node being inserted as left child of its parent.

After insertion of 13,

Predecessor of 14 becomes the predecessor of 13, so left thread of 13 points to 10.
Successor of 13 is 14, so right thread of 13 points to left child which is 13.
Left pointer of 14 is not a thread now, it points to left child which is 13.

Case 3: When new node is inserted as the right child
The parent of tmp is its inorder predecessor. The node which was inorder successor of the parent is now the inorder successor of this node tmp. So the left and right threads of the new node will be-

```tmp -> left = par;
tmp -> right = par -> right;```

Before insertion, the right pointer of parent was a thread, but after insertion it will be a link pointing to the new node.

```par -> rthread = false;
par -> right = tmp;```

Following example shows a node being inserted as right child of its parent.

After 15 inserted,

Successor of 14 becomes the successor of 15, so right thread of 15 points to 16
Predecessor of 15 is 14, so left thread of 15 points to 14.
Right pointer of 14 is not a thread now, it points to right child which is 15.

C++ implementation to insert a new node in Threaded Binary Search Tree:
Like standard BST insert, we search for the key value in the tree. If key is already present, then we return otherwise the new key is inserted at the point where search terminates. In BST, search terminates either when we find the key or when we reach a NULL left or right pointer. Here all left and right NULL pointers are replaced by threads except left pointer of first node and right pointer of last node. So here search will be unsuccessful when we reach a NULL pointer or a thread.

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

 `// Insertion in Threaded Binary Search Tree. ` `#include ` `using` `namespace` `std; ` ` `  `struct` `Node ` `{ ` `    ``struct` `Node *left, *right; ` `    ``int` `info; ` ` `  `    ``// True if left pointer points to predecessor ` `    ``// in Inorder Traversal ` `    ``bool` `lthread; ` ` `  `    ``// True if right pointer points to predecessor ` `    ``// in Inorder Traversal ` `    ``bool` `rthread; ` `}; ` ` `  `// Insert a Node in Binary Threaded Tree ` `struct` `Node *insert(``struct` `Node *root, ``int` `ikey) ` `{ ` `    ``// Searching for a Node with given value ` `    ``Node *ptr = root; ` `    ``Node *par = NULL; ``// Parent of key to be inserted ` `    ``while` `(ptr != NULL) ` `    ``{ ` `        ``// If key already exists, return ` `        ``if` `(ikey == (ptr->info)) ` `        ``{ ` `            ``printf``(``"Duplicate Key !\n"``); ` `            ``return` `root; ` `        ``} ` ` `  `        ``par = ptr; ``// Update parent pointer ` ` `  `        ``// Moving on left subtree. ` `        ``if` `(ikey < ptr->info) ` `        ``{ ` `            ``if` `(ptr -> lthread == ``false``) ` `                ``ptr = ptr -> left; ` `            ``else` `                ``break``; ` `        ``} ` ` `  `        ``// Moving on right subtree. ` `        ``else` `        ``{ ` `            ``if` `(ptr->rthread == ``false``) ` `                ``ptr = ptr -> right; ` `            ``else` `                ``break``; ` `        ``} ` `    ``} ` ` `  `    ``// Create a new node ` `    ``Node *tmp = ``new` `Node; ` `    ``tmp -> info = ikey; ` `    ``tmp -> lthread = ``true``; ` `    ``tmp -> rthread = ``true``; ` ` `  `    ``if` `(par == NULL) ` `    ``{ ` `        ``root = tmp; ` `        ``tmp -> left = NULL; ` `        ``tmp -> right = NULL; ` `    ``} ` `    ``else` `if` `(ikey < (par -> info)) ` `    ``{ ` `        ``tmp -> left = par -> left; ` `        ``tmp -> right = par; ` `        ``par -> lthread = ``false``; ` `        ``par -> left = tmp; ` `    ``} ` `    ``else` `    ``{ ` `        ``tmp -> left = par; ` `        ``tmp -> right = par -> right; ` `        ``par -> rthread = ``false``; ` `        ``par -> right = tmp; ` `    ``} ` ` `  `    ``return` `root; ` `} ` ` `  `// Returns inorder successor using rthread ` `struct` `Node *inorderSuccessor(``struct` `Node *ptr) ` `{ ` `    ``// If rthread is set, we can quickly find ` `    ``if` `(ptr -> rthread == ``true``) ` `        ``return` `ptr->right; ` ` `  `    ``// Else return leftmost child of right subtree ` `    ``ptr = ptr -> right; ` `    ``while` `(ptr -> lthread == ``false``) ` `        ``ptr = ptr -> left; ` `    ``return` `ptr; ` `} ` ` `  `// Printing the threaded tree ` `void` `inorder(``struct` `Node *root) ` `{ ` `    ``if` `(root == NULL) ` `        ``printf``(``"Tree is empty"``); ` ` `  `    ``// Reach leftmost node ` `    ``struct` `Node *ptr = root; ` `    ``while` `(ptr -> lthread == ``false``) ` `        ``ptr = ptr -> left; ` ` `  `    ``// One by one print successors ` `    ``while` `(ptr != NULL) ` `    ``{ ` `        ``printf``(``"%d "``,ptr -> info); ` `        ``ptr = inorderSuccessor(ptr); ` `    ``} ` `} ` ` `  `// Driver Program ` `int` `main() ` `{ ` `    ``struct` `Node *root = NULL; ` ` `  `    ``root = insert(root, 20); ` `    ``root = insert(root, 10); ` `    ``root = insert(root, 30); ` `    ``root = insert(root, 5); ` `    ``root = insert(root, 16); ` `    ``root = insert(root, 14); ` `    ``root = insert(root, 17); ` `    ``root = insert(root, 13); ` ` `  `    ``inorder(root); ` ` `  `    ``return` `0; ` `} `

 `// Java program Insertion in Threaded Binary Search Tree.  ` `import` `java.util.*; ` `class` `solution ` `{ ` `static` `class` `Node  ` `{  ` `     ``Node left, right;  ` `    ``int` `info;  ` `   `  `    ``// True if left pointer points to predecessor  ` `    ``// in Inorder Traversal  ` `    ``boolean` `lthread;  ` `   `  `    ``// True if right pointer points to predecessor  ` `    ``// in Inorder Traversal  ` `    ``boolean` `rthread;  ` `};  ` `   `  `// Insert a Node in Binary Threaded Tree  ` `static` `Node insert( Node root, ``int` `ikey)  ` `{  ` `    ``// Searching for a Node with given value  ` `    ``Node ptr = root;  ` `    ``Node par = ``null``; ``// Parent of key to be inserted  ` `    ``while` `(ptr != ``null``)  ` `    ``{  ` `        ``// If key already exists, return  ` `        ``if` `(ikey == (ptr.info))  ` `        ``{  ` `            ``System.out.printf(``"Duplicate Key !\n"``);  ` `            ``return` `root;  ` `        ``}  ` `   `  `        ``par = ptr; ``// Update parent pointer  ` `   `  `        ``// Moving on left subtree.  ` `        ``if` `(ikey < ptr.info)  ` `        ``{  ` `            ``if` `(ptr . lthread == ``false``)  ` `                ``ptr = ptr . left;  ` `            ``else` `                ``break``;  ` `        ``}  ` `   `  `        ``// Moving on right subtree.  ` `        ``else` `        ``{  ` `            ``if` `(ptr.rthread == ``false``)  ` `                ``ptr = ptr . right;  ` `            ``else` `                ``break``;  ` `        ``}  ` `    ``}  ` `   `  `    ``// Create a new node  ` `    ``Node tmp = ``new` `Node();  ` `    ``tmp . info = ikey;  ` `    ``tmp . lthread = ``true``;  ` `    ``tmp . rthread = ``true``;  ` `     `  `    ``if` `(par == ``null``)  ` `    ``{  ` `        ``root = tmp;  ` `        ``tmp . left = ``null``;  ` `        ``tmp . right = ``null``;  ` `    ``}  ` `    ``else` `if` `(ikey < (par . info))  ` `    ``{  ` `        ``tmp . left = par . left;  ` `        ``tmp . right = par;  ` `        ``par . lthread = ``false``;  ` `        ``par . left = tmp;  ` `    ``}  ` `    ``else` `    ``{  ` `        ``tmp . left = par;  ` `        ``tmp . right = par . right;  ` `        ``par . rthread = ``false``;  ` `        ``par . right = tmp;  ` `    ``}  ` `   `  `    ``return` `root;  ` `}  ` `   `  `// Returns inorder successor using rthread  ` `static`  `Node inorderSuccessor( Node ptr)  ` `{  ` `    ``// If rthread is set, we can quickly find  ` `    ``if` `(ptr . rthread == ``true``)  ` `        ``return` `ptr.right;  ` `   `  `    ``// Else return leftmost child of right subtree  ` `    ``ptr = ptr . right;  ` `    ``while` `(ptr . lthread == ``false``)  ` `        ``ptr = ptr . left;  ` `    ``return` `ptr;  ` `}  ` `   `  `// Printing the threaded tree  ` `static` `void` `inorder( Node root)  ` `{  ` `    ``if` `(root == ``null``)  ` `        ``System.out.printf(``"Tree is empty"``);  ` `   `  `    ``// Reach leftmost node  ` `     ``Node ptr = root;  ` `    ``while` `(ptr . lthread == ``false``)  ` `        ``ptr = ptr . left;  ` `   `  `    ``// One by one print successors  ` `    ``while` `(ptr != ``null``)  ` `    ``{  ` `        ``System.out.printf(``"%d "``,ptr . info);  ` `        ``ptr = inorderSuccessor(ptr);  ` `    ``}  ` `}  ` `   `  `// Driver Program  ` `public` `static` `void` `main(String[] args) ` `{  ` `     ``Node root = ``null``;  ` `   `  `    ``root = insert(root, ``20``);  ` `    ``root = insert(root, ``10``);  ` `    ``root = insert(root, ``30``);  ` `    ``root = insert(root, ``5``);  ` `    ``root = insert(root, ``16``);  ` `    ``root = insert(root, ``14``);  ` `    ``root = insert(root, ``17``);  ` `    ``root = insert(root, ``13``);  ` `   `  `    ``inorder(root);  ` `}   ` `} ` `//contributed by Arnab Kundu `

 `# Insertion in Threaded Binary Search Tree.  ` `class` `newNode: ` `    ``def` `__init__(``self``, key): ` `     `  `        ``# True if left pointer points to  ` `        ``# predecessor in Inorder Traversal  ` `        ``self``.info ``=` `key ` `        ``self``.left ``=` `None` `        ``self``.right ``=``None` `        ``self``.lthread ``=` `True` `     `  `        ``# True if right pointer points to  ` `        ``# predecessor in Inorder Traversal  ` `        ``self``.rthread ``=` `True` ` `  `# Insert a Node in Binary Threaded Tree  ` `def` `insert(root, ikey): ` `     `  `    ``# Searching for a Node with given value  ` `    ``ptr ``=` `root  ` `    ``par ``=` `None` `# Parent of key to be inserted  ` `    ``while` `ptr !``=` `None``: ` `         `  `        ``# If key already exists, return  ` `        ``if` `ikey ``=``=` `(ptr.info): ` `            ``print``(``"Duplicate Key !"``)  ` `            ``return` `root  ` ` `  `        ``par ``=` `ptr ``# Update parent pointer  ` ` `  `        ``# Moving on left subtree.  ` `        ``if` `ikey < ptr.info: ` `            ``if` `ptr.lthread ``=``=` `False``:  ` `                ``ptr ``=` `ptr.left  ` `            ``else``: ` `                ``break` ` `  `        ``# Moving on right subtree.  ` `        ``else``: ` `            ``if` `ptr.rthread ``=``=` `False``:  ` `                ``ptr ``=` `ptr.right  ` `            ``else``: ` `                ``break` ` `  `    ``# Create a new node  ` `    ``tmp ``=` `newNode(ikey)  ` ` `  `    ``if` `par ``=``=` `None``: ` `        ``root ``=` `tmp  ` `        ``tmp.left ``=` `None` `        ``tmp.right ``=` `None` `    ``elif` `ikey < (par.info): ` `        ``tmp.left ``=` `par.left  ` `        ``tmp.right ``=` `par  ` `        ``par.lthread ``=` `False` `        ``par.left ``=` `tmp ` `    ``else``: ` `        ``tmp.left ``=` `par  ` `        ``tmp.right ``=` `par.right  ` `        ``par.rthread ``=` `False` `        ``par.right ``=` `tmp ` ` `  `    ``return` `root ` ` `  `# Returns inorder successor using rthread  ` `def` `inorderSuccessor(ptr): ` `     `  `    ``# If rthread is set, we can quickly find  ` `    ``if` `ptr.rthread ``=``=` `True``:  ` `        ``return` `ptr.right  ` ` `  `    ``# Else return leftmost child of  ` `    ``# right subtree  ` `    ``ptr ``=` `ptr.right  ` `    ``while` `ptr.lthread ``=``=` `False``:  ` `        ``ptr ``=` `ptr.left  ` `    ``return` `ptr ` ` `  `# Printing the threaded tree  ` `def` `inorder(root): ` `    ``if` `root ``=``=` `None``:  ` `        ``print``(``"Tree is empty"``)  ` ` `  `    ``# Reach leftmost node  ` `    ``ptr ``=` `root  ` `    ``while` `ptr.lthread ``=``=` `False``:  ` `        ``ptr ``=` `ptr.left  ` ` `  `    ``# One by one print successors  ` `    ``while` `ptr !``=` `None``: ` `        ``print``(ptr.info,end``=``" "``)  ` `        ``ptr ``=` `inorderSuccessor(ptr) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``root ``=` `None` ` `  `    ``root ``=` `insert(root, ``20``)  ` `    ``root ``=` `insert(root, ``10``)  ` `    ``root ``=` `insert(root, ``30``)  ` `    ``root ``=` `insert(root, ``5``)  ` `    ``root ``=` `insert(root, ``16``)  ` `    ``root ``=` `insert(root, ``14``)  ` `    ``root ``=` `insert(root, ``17``)  ` `    ``root ``=` `insert(root, ``13``)  ` ` `  `    ``inorder(root)  ` `     `  `# This code is contributed by PranchalK `

 `using` `System; ` ` `  `// C# program Insertion in Threaded Binary Search Tree.   ` `public` `class` `solution ` `{ ` `public` `class` `Node ` `{ ` `     ``public` `Node left, right; ` `    ``public` `int` `info; ` ` `  `    ``// True if left pointer points to predecessor   ` `    ``// in Inorder Traversal   ` `    ``public` `bool` `lthread; ` ` `  `    ``// True if right pointer points to predecessor   ` `    ``// in Inorder Traversal   ` `    ``public` `bool` `rthread; ` `} ` ` `  `// Insert a Node in Binary Threaded Tree   ` `public` `static` `Node insert(Node root, ``int` `ikey) ` `{ ` `    ``// Searching for a Node with given value   ` `    ``Node ptr = root; ` `    ``Node par = ``null``; ``// Parent of key to be inserted ` `    ``while` `(ptr != ``null``) ` `    ``{ ` `        ``// If key already exists, return   ` `        ``if` `(ikey == (ptr.info)) ` `        ``{ ` `            ``Console.Write(``"Duplicate Key !\n"``); ` `            ``return` `root; ` `        ``} ` ` `  `        ``par = ptr; ``// Update parent pointer ` ` `  `        ``// Moving on left subtree.   ` `        ``if` `(ikey < ptr.info) ` `        ``{ ` `            ``if` `(ptr.lthread == ``false``) ` `            ``{ ` `                ``ptr = ptr.left; ` `            ``} ` `            ``else` `            ``{ ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// Moving on right subtree.   ` `        ``else` `        ``{ ` `            ``if` `(ptr.rthread == ``false``) ` `            ``{ ` `                ``ptr = ptr.right; ` `            ``} ` `            ``else` `            ``{ ` `                ``break``; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Create a new node   ` `    ``Node tmp = ``new` `Node(); ` `    ``tmp.info = ikey; ` `    ``tmp.lthread = ``true``; ` `    ``tmp.rthread = ``true``; ` ` `  `    ``if` `(par == ``null``) ` `    ``{ ` `        ``root = tmp; ` `        ``tmp.left = ``null``; ` `        ``tmp.right = ``null``; ` `    ``} ` `    ``else` `if` `(ikey < (par.info)) ` `    ``{ ` `        ``tmp.left = par.left; ` `        ``tmp.right = par; ` `        ``par.lthread = ``false``; ` `        ``par.left = tmp; ` `    ``} ` `    ``else` `    ``{ ` `        ``tmp.left = par; ` `        ``tmp.right = par.right; ` `        ``par.rthread = ``false``; ` `        ``par.right = tmp; ` `    ``} ` ` `  `    ``return` `root; ` `} ` ` `  `// Returns inorder successor using rthread   ` `public` `static` `Node inorderSuccessor(Node ptr) ` `{ ` `    ``// If rthread is set, we can quickly find   ` `    ``if` `(ptr.rthread == ``true``) ` `    ``{ ` `        ``return` `ptr.right; ` `    ``} ` ` `  `    ``// Else return leftmost child of right subtree   ` `    ``ptr = ptr.right; ` `    ``while` `(ptr.lthread == ``false``) ` `    ``{ ` `        ``ptr = ptr.left; ` `    ``} ` `    ``return` `ptr; ` `} ` ` `  `// Printing the threaded tree   ` `public` `static` `void` `inorder(Node root) ` `{ ` `    ``if` `(root == ``null``) ` `    ``{ ` `        ``Console.Write(``"Tree is empty"``); ` `    ``} ` ` `  `    ``// Reach leftmost node   ` `     ``Node ptr = root; ` `    ``while` `(ptr.lthread == ``false``) ` `    ``{ ` `        ``ptr = ptr.left; ` `    ``} ` ` `  `    ``// One by one print successors   ` `    ``while` `(ptr != ``null``) ` `    ``{ ` `        ``Console.Write(``"{0:D} "``,ptr.info); ` `        ``ptr = inorderSuccessor(ptr); ` `    ``} ` `} ` ` `  `// Driver Program   ` `public` `static` `void` `Main(``string``[] args) ` `{ ` `     ``Node root = ``null``; ` ` `  `    ``root = insert(root, 20); ` `    ``root = insert(root, 10); ` `    ``root = insert(root, 30); ` `    ``root = insert(root, 5); ` `    ``root = insert(root, 16); ` `    ``root = insert(root, 14); ` `    ``root = insert(root, 17); ` `    ``root = insert(root, 13); ` ` `  `    ``inorder(root); ` `} ` `} ` ` `  `  ``// This code is contributed by Shrikant13 `

Output:
```5 10 13 14 16 17 20 30
```

This article is contributed by Anuj Chauhan. 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.