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

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

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

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

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

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.