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
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; } |
chevron_right
filter_none
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 |
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 |
chevron_right
filter_none
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 |
chevron_right
filter_none
Output:
20 30 40 50 60 70 80
Recommended Posts:
- Binary Search Tree insert with Parent Pointer
- Search a node in Binary Tree
- Postorder predecessor of a Node in Binary Search Tree
- Find the node with maximum value in a Binary Search Tree
- Find the node with minimum value in a Binary Search Tree
- Find the node with minimum value in a Binary Search Tree using recursion
- Find the node with maximum value in a Binary Search Tree using recursion
- Minimum swap required to convert binary tree to binary search tree
- Complexity of different operations in Binary tree, Binary Search Tree and AVL tree
- Binary Search Tree | Set 1 (Search and Insertion)
- Count the Number of Binary Search Trees present in a Binary Tree
- Binary Tree to Binary Search Tree Conversion
- Binary Tree to Binary Search Tree Conversion using STL set
- Floor in Binary Search Tree (BST)
- Sum of all the levels in a Binary Search Tree
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.
