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.

Below is the implementation of the above approach:

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

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

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

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



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.





Article Tags :
Practice Tags :