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

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


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


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

"""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 =
        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
  
# 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

chevron_right


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


Output:

20 30 40 50 60 70 80


My Personal Notes arrow_drop_up

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.