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


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 right child of y if x->key is less than y->key. Else, if y->key is greater than x->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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// 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 



















                        chevron_right







                        filter_none









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


[tabby title="C#"]

                











                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// 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 



















                        chevron_right







                        filter_none











Output:


20 30 40 50 60 70 80






          
          
          
          

            

    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
tufan_gupta2000
Check out this Author's contributed articles.
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.
Please Improve this article if you find anything incorrect by clicking on  the "Improve Article" button below.