Threaded Binary Tree | Insertion

10 Mar, 2022
We have already discuss the Binary Threaded Binary Tree.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;

  // false if left pointer points to predecessor 
  // in Inorder Traversal
  boolean lthread; 

  // false if right pointer points to successor 
  // in Inorder Traversal
  boolean rthread; 
};
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.
C++
Java
Python3
C#
Javascript
// Insertion in Threaded Binary Search Tree.#include<bits/stdc++.h>using namespace std; struct Node{    struct Node *left, *right;    int info;     // False if left pointer points to predecessor    // in Inorder Traversal    bool lthread;     // False if right pointer points to successor    // in Inorder Traversal    bool rthread;}; // Insert a Node in Binary Threaded Treestruct 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 rthreadstruct 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 treevoid 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 Programint 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;       // False if left pointer points to predecessor    // in Inorder Traversal    boolean lthread;       // False if right pointer points to successor    // in Inorder Traversal    boolean rthread;};   // Insert a Node in Binary Threaded Treestatic 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 rthreadstatic  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 treestatic 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 Programpublic 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):             # False if left pointer points to        # predecessor in Inorder Traversal        self.info = key        self.left = None        self.right =None        self.lthread = True             # False if right pointer points to        # successor in Inorder Traversal        self.rthread = True # Insert a Node in Binary Threaded Treedef 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    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 rthreaddef 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 treedef 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 Codeif __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;     // False if left pointer points to predecessor     // in Inorder Traversal     public bool lthread;     // False if right pointer points to successor     // 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
<script>// javascript program Insertion in Threaded Binary Search Tree.     class Node {     constructor(){this.left = null, this.right = null;        this.info = 0;         // False if left pointer points to predecessor        // in Inorder Traversal        this.lthread = false;         // False if right pointer points to successor        // in Inorder Traversal        this.rthread = false;    }    }     // Insert a Node in Binary Threaded Tree    function insert(root , ikey) {        // Searching for a Node with given valuevar ptr = root;var par = null; // Parent of key to be inserted        while (ptr != null) {            // If key already exists, return            if (ikey == (ptr.info)) {                document.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 nodevar 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    function 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    function inorder(root) {        if (root == null)            document.write("Tree is empty");         // Reach leftmost nodevar ptr = root;        while (ptr.lthread == false)            ptr = ptr.left;         // One by one print successors        while (ptr != null) {            document.write(ptr.info+" ");            ptr = inorderSuccessor(ptr);        }    }     // Driver Program     var 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 contributed by aashish1995</script>
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 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.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
andrew1234
shrikanth13
PranchalKatiyar
ronaksanpui
aashish1995
hguru001
Kirti_Mangal
simmytarika5
threaded-binary-tree
Binary Search Tree
Tree
Binary Search Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
A program to check if a binary tree is BST or not
Find postorder traversal of BST from preorder traversal
Overview of Data Structures | Set 2 (Binary Tree, BST, Heap and Hash)
Optimal Binary Search Tree | DP-24
Sorted Array to Balanced BST
Tree Traversals (Inorder, Preorder and Postorder)
Binary Tree | Set 1 (Introduction)
Level Order Binary Tree Traversal
Introduction to Data Structures
Introduction to Tree Data Structure