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 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++
// 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
[tabby title="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
- Find the node with maximum value in a Binary Search Tree
- Postorder predecessor of a Node in Binary Search Tree
- Find the node with minimum value in a Binary Search Tree
- Find the node with maximum value in a Binary Search Tree using recursion
- Find the node with minimum 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 using STL set
- Binary Tree to Binary Search Tree Conversion
- K-th ancestor of a node in Binary Tree | Set 3
- K-th ancestor of a node in Binary 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.
- Iterative Method To Print Left View of a Binary Tree
- Check if given Preorder, Inorder and Postorder traversals are of same tree | Set 2
- Zig-Zag traversal of a Binary Tree using Recursion
- Sum of the distances from every node to all other nodes is maximum
- Convert a given Binary Tree to Circular Doubly Linked List | Set 2
