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


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

“””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


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.