 Open in App
Not now

# How to insert a node in Binary Search Tree using Iteration

• Difficulty Level : Medium
• Last Updated : 17 Aug, 2022

You are given a binary search tree (BST) and a value to insert into the tree. Print inorder traversal of the BST after the insertion.
Example:

Input:To the given BST insert 40 Output: Explanation:The new node 40 is a leaf node. Start searching from the root till a leaf node is hit, i.e while searching if a new value is greater than current node move to right child else to left child.

Input:To the given BST insert 600 Output: Explanation: The new node 600 is a leaf node. Start searching from the root till a leaf node is hit, i.e while searching if a new value is greater than current node move to right child else to left child.

Approach:

As we all know that a new key is always inserted at the leaf node. so we 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 with the given value, while searching if the value of current node is greater then the given value then move to the left , else move to right

Follow the steps mentioned below to implement the idea:

• Start from the root and run a loop until a null pointer is reached.
• Keep the previous pointer of the current node stored.
• If the current node is null then create and insert the new node there and make it as one of the children of the parent/previous node depending on its value.
• If the value of current node is less than the new value then move to the right child of current node else move to the left child.

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;` `};`   `// Utility 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 than 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 inorder 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;` `    ``};`   `    ``// Utility 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 than 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 inorder 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 than 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``)`   `    ``# Pr inorder 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;` `    ``};`   `    ``// Utility 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 than 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 inorder traversal of the BST` `        ``Inorder(root);` `    ``}` `}`   `// This code is contributed 29AjayKumar`

## Javascript

 ``

Output

`20 30 40 50 60 70 80 `

Time Complexity: O(H), where H is the height of the BST.
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles