# 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
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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++ program to demonstrate insert operation ` `// in binary search tree ` `#include ` `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; ` `} `

 `// 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 `

 `"""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 `

 `// 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 `

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 :