Insert a node in Binary Search Tree Iteratively

A recursive approach to insert a new node in a BST is already discussed in the post: Binary Search Tree | SET 1. In this post, an iterative approach to insert a node in BST is discussed.

Insertion of a Key

A new key is always inserted at the leaf node. Start searching a key from root till we hit a leaf node. Once a leaf node is found, the new node is added as a child of the leaf node.

Example:

     100                             100
    /   \        Insert 40          /    \
  20     500     --------->       20     500 
 /  \                            /  \  
10   30                         10   30
                                        \   
                                        40

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

Approach: The idea is to note that new keys are always inserted at the leaf node.

Take a temporary pointer named $x$ and start from the root node to traverse the tree downwards to find the correct leaf node at which the key is to be inserted.
Also, keep track of the trailing pointer y to find the parent of the new node.
After getting the final values of x and y, assign x as the left child of y if x->key is less than y->key. Else, if x->key is greater than y->key, assign x as the right child of y.(If the tree is NULL then the new node is made the root node.)

Below is the implementation of the above approach:

C++

// C++ program to demonstrate insert operation 
// in binary search tree 
#include <bits/stdc++.h> 
using namespace std; 
  
// BST node 
struct Node { 
    int key; 
    struct Node *left, *right; 
}; 
  
// Utitlity function to create a new node 
Node* newNode(int data) 
{ 
    Node* temp = new Node; 
  
    temp->key = data; 
  
    temp->left = NULL; 
    temp->right = NULL; 
  
    return temp; 
} 
  
// A utility function to insert a new 
// Node with given key in BST 
Node* insert(Node* root, int key) 
{ 
    // Create a new Node containing 
    // the new element 
    Node* newnode = newNode(key); 
  
    // Pointer to start traversing from root and 
    // traverses downward path to search 
    // where the new node to be inserted 
    Node* x = root; 
  
    // Pointer y maintains the trailing 
    // pointer of x 
    Node* y = NULL; 
  
    while (x != NULL) { 
        y = x; 
        if (key < x->key) 
            x = x->left; 
        else
            x = x->right; 
    } 
  
    // If the root is NULL i.e the tree is empty 
    // The new node is the root node 
    if (y == NULL) 
        y = newnode; 
  
    // If the new key is less then the leaf node key 
    // Assign the new node to be its left child 
    else if (key < y->key) 
        y->left = newnode; 
  
    // else assign the new node its right child 
    else
        y->right = newnode; 
  
    // Returns the pointer where the 
    // new node is inserted 
    return y; 
} 
  
// A utility function to do inorder 
// traversal of BST 
void Inorder(Node* root) 
{ 
    if (root == NULL) 
        return; 
    else { 
        Inorder(root->left); 
        cout << root->key << " "; 
        Inorder(root->right); 
    } 
} 
  
// Driver code 
int main() 
{ 
    /* Let us create following BST  
            50  
          /   \  
        30      70  
        / \   / \  
       20 40 60 80 */
  
    Node* root = NULL; 
    root = insert(root, 50); 
    insert(root, 30); 
    insert(root, 20); 
    insert(root, 40); 
    insert(root, 70); 
    insert(root, 60); 
    insert(root, 80); 
  
    // Print inoder traversal of the BST 
    Inorder(root); 
  
    return 0; 
} 

Java

// Java program to demonstrate insert operation  
// in binary search tree  
import java.util.*; 
class solution 
{ 
    
// BST node  
static class Node {  
    int key;  
     Node left, right;  
};  
    
// Utitlity function to create a new node  
static Node newNode(int data)  
{  
    Node temp = new Node();  
    
    temp.key = data;  
    
    temp.left = null;  
    temp.right = null;  
    
    return temp;  
}  
    
// A utility function to insert a new  
// Node with given key in BST  
static Node insert(Node root, int key)  
{  
    // Create a new Node containing  
    // the new element  
    Node newnode = newNode(key);  
    
    // Pointer to start traversing from root and  
    // traverses downward path to search  
    // where the new node to be inserted  
    Node x = root;  
    
    // Pointer y maintains the trailing  
    // pointer of x  
    Node y = null;  
    
    while (x != null) {  
        y = x;  
        if (key < x.key)  
            x = x.left;  
        else
            x = x.right;  
    }  
    
    // If the root is null i.e the tree is empty  
    // The new node is the root node  
    if (y == null)  
        y = newnode;  
    
    // If the new key is less then the leaf node key  
    // Assign the new node to be its left child  
    else if (key < y.key)  
        y.left = newnode;  
    
    // else assign the new node its right child  
    else
        y.right = newnode;  
    
    // Returns the pointer where the  
    // new node is inserted  
    return y;  
}  
    
// A utility function to do inorder  
// traversal of BST  
static void Inorder(Node root)  
{  
    if (root == null)  
        return;  
    else {  
        Inorder(root.left);  
        System.out.print( root.key +" ");  
        Inorder(root.right);  
    }  
}  
    
// Driver code  
public static void main(String args[])  
{  
    /* Let us create following BST   
            50   
          /   \   
        30      70   
        / \   / \   
       20 40 60 80 */
    
    Node root = null;  
    root = insert(root, 50);  
    insert(root, 30);  
    insert(root, 20);  
    insert(root, 40);  
    insert(root, 70);  
    insert(root, 60);  
    insert(root, 80);  
    
    // Print inoder traversal of the BST  
    Inorder(root);  
    
}  
} 
//contributed by Arnab Kundu 

Python3

"""Python3 program to demonstrate insert  
operation in binary search tree """
  
# A Binary Tree Node  
# Utility function to create a 
# new tree node  
class newNode:  
  
    # Constructor to create a newNode  
    def __init__(self, data):  
        self.key= data  
        self.left = None
        self.right = self.parent = None
  
# A utility function to insert a new  
# Node with given key in BST  
def insert(root, key): 
  
    # Create a new Node containing  
    # the new element  
    newnode = newNode(key)  
  
    # Pointer to start traversing from root  
    # and traverses downward path to search  
    # where the new node to be inserted  
    x = root  
  
    # Pointer y maintains the trailing  
    # pointer of x  
    y = None
  
    while (x != None): 
        y = x  
        if (key < x.key): 
            x = x.left  
        else: 
            x = x.right  
      
    # If the root is None i.e the tree is  
    # empty. The new node is the root node  
    if (y == None): 
        y = newnode  
  
    # If the new key is less then the leaf node key  
    # Assign the new node to be its left child  
    elif (key < y.key): 
        y.left = newnode  
  
    # else assign the new node its  
    # right child  
    else: 
        y.right = newnode  
  
    # Returns the pointer where the  
    # new node is inserted  
    return y  
  
# A utility function to do inorder  
# traversal of BST  
def Inorder(root) : 
  
    if (root == None) : 
        return
    else:  
        Inorder(root.left)  
        print( root.key, end = " " ) 
        Inorder(root.right) 
                          
# Driver Code 
if __name__ == '__main__': 
  
    """ Let us create following BST  
            50  
        / \  
        30     70  
        / \ / \  
    20 40 60 80 """
  
    root = None
    root = insert(root, 50)  
    insert(root, 30)  
    insert(root, 20)  
    insert(root, 40)  
    insert(root, 70)  
    insert(root, 60)  
    insert(root, 80)  
  
    # Prinoder traversal of the BST  
    Inorder(root) 
  
# This code is contributed by 
# SHUBHAMSINGH10 

C#

// C# program to demonstrate insert   
// operation in binary search tree 
using System; 
  
class GFG  
{  
    // BST node  
    class Node  
    {  
        public int key;  
        public Node left, right;  
    };  
  
    // Utitlity function to create a new node  
    static Node newNode(int data)  
    {  
        Node temp = new Node();  
  
        temp.key = data;  
  
        temp.left = null;  
        temp.right = null;  
  
        return temp;  
    }  
  
    // A utility function to insert a new  
    // Node with given key in BST  
    static Node insert(Node root, int key)  
    {  
        // Create a new Node containing  
        // the new element  
        Node newnode = newNode(key);  
  
        // Pointer to start traversing from root and  
        // traverses downward path to search  
        // where the new node to be inserted  
        Node x = root;  
  
        // Pointer y maintains the trailing  
        // pointer of x  
        Node y = null;  
  
        while (x != null)  
        {  
            y = x;  
            if (key < x.key)  
                x = x.left;  
            else
                x = x.right;  
        }  
  
        // If the root is null i.e the tree is empty  
        // The new node is the root node  
        if (y == null)  
            y = newnode;  
  
        // If the new key is less then the leaf node key  
        // Assign the new node to be its left child  
        else if (key < y.key)  
            y.left = newnode;  
  
        // else assign the new node its right child  
        else
            y.right = newnode;  
  
        // Returns the pointer where the  
        // new node is inserted  
        return y;  
    }  
  
    // A utility function to do inorder  
    // traversal of BST  
    static void Inorder(Node root)  
    {  
        if (root == null)  
            return;  
        else 
        {  
            Inorder(root.left);  
            Console.Write( root.key +" ");  
            Inorder(root.right);  
        }  
    }  
  
    // Driver code  
    public static void Main(String []args)  
    {  
        /* Let us create following BST  
                50  
            / \  
            30 70  
            / \ / \  
        20 40 60 80 */
  
        Node root = null;  
        root = insert(root, 50);  
        insert(root, 30);  
        insert(root, 20);  
        insert(root, 40);  
        insert(root, 70);  
        insert(root, 60);  
        insert(root, 80);  
  
        // Print inoder traversal of the BST  
        Inorder(root);  
    }  
}  
  
// This code is contributed 29AjayKumar 

Output:

20 30 40 50 60 70 80

My Personal Notes

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

C++

Java

Python3

C#

Recommended Posts: