Insertion in a Binary Tree in level order

Last Updated : 24 Mar, 2025

Given a binary tree and a key, the task is to insert the key into the binary tree at the first position available in level order manner.

Examples:

Input: key = 12

Output:

Explanation: Node with value 12 is inserted into the binary tree at the first position available in level order manner.

Approach:

The idea is to do an iterative level order traversal of the given tree using queue. If we find a node whose left child is empty, we make a new key as the left child of the node. Else if we find a node whose right child is empty, we make the new key as the right child. We keep traversing the tree until we find a node whose either left or right child is empty

Below is the implementation of the above approach:

C++

// C++ program to insert element (in level order)
// in Binary Tree
#include <iostream>
#include <queue>
using namespace std;

class Node {
public: 
  	int data;
    Node* left;
    Node* right;
	Node(int x) {
    	data = x;
      	left = right = nullptr;
    }
};

// Function to insert element in binary tree
Node* InsertNode(Node* root, int data) {
  
    // If the tree is empty, assign new
  	// node address to root
    if (root == nullptr) {
        root = new Node(data);
        return root;
    }

    // Else, do level order traversal until we find an empty
    // place, i.e. either left child or right child of some
    // node is pointing to NULL.
    queue<Node*> q;
    q.push(root);

    while (!q.empty()) {
      
      	// Fron a front element in queue
        Node* curr = q.front();
        q.pop();
		
      	// First check left if left is null 
      	// insert node in left otherwise chaeck for right
        if (curr->left != nullptr)
            q.push(curr->left);
        else {
            curr->left = new Node(data);
            return root;
        }
	
        if (curr->right != nullptr)
            q.push(curr->right);
        else {
            curr->right = new Node(data);
            return root;
        }
    }
}

// Inorder traversal of a binary tree 
void inorder(Node* curr) {
    if (curr == nullptr)
        return;
    inorder(curr->left);
    cout << curr->data << ' ';
    inorder(curr->right);
}

int main() {
  
  	// Constructing the binary tree
  	//          10
    //        /    \ 
    //       11     9
    //      /      / \
    //     7      15   8
  
    Node* root = new Node(10);
    root->left = new Node(11);
  	root->right = new Node(9);
    root->left->left = new Node(7);
    root->right->left = new Node(15);
    root->right->right = new Node(8);
  
    int key = 12;
    root = InsertNode(root, key);
  
  	// After insertion 12 in binary tree
  	//          10
    //        /    \ 
    //       11     9
    //      /  \   / \
    //     7   12 15  8

    inorder(root);

    return 0;
}

Java

// Java program to insert element (in level order)
// in Binary Tree
import java.util.LinkedList;
import java.util.Queue;

class Node {
    int data;
    Node left, right;
    
    Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {
  
    // Function to insert element 
  	// in binary tree
    static Node InsertNode(Node root, int data) {
      
        // If the tree is empty, assign new node 
      	// address to root
        if (root == null) {
            root = new Node(data);
            return root;
        }

        // Else, do level order traversal until we find an empty
        // place, i.e. either left child or right child of some
        // node is pointing to NULL.
        Queue<Node> q = new LinkedList<>();
        q.add(root);

        while (!q.isEmpty()) {
          
            // Fron a front element in queue
            Node curr = q.poll();

            // First check left if left is null insert
          	// node in left otherwise chaeck for right
            if (curr.left != null)
                q.add(curr.left);
            else {
                curr.left = new Node(data);
                return root;
            }

            if (curr.right != null)
                q.add(curr.right);
            else {
                curr.right = new Node(data);
                return root;
            }
        }
        return root;
    }

    // Inorder traversal of a binary tree
    static void inorder(Node curr) {
        if (curr == null)
            return;
        inorder(curr.left);
        System.out.print(curr.data + " ");
        inorder(curr.right);
    }

    public static void main(String[] args) {
      
        // Constructing the binary tree
        //          10
        //        /    \ 
        //       11     9
        //      /      / \
        //     7      15   8
        Node root = new Node(10);
        root.left = new Node(11);
        root.right = new Node(9);
        root.left.left = new Node(7);
        root.right.left = new Node(15);
        root.right.right = new Node(8);

        int key = 12;
        root = InsertNode(root, key);

        // After insertion 12 in binary tree
        //          10
        //        /    \ 
        //       11     9
        //      /  \   / \
        //     7   12 15  8
        inorder(root);
    }
}

Python

# Python program to insert element (in level order)
# in Binary Tree
from collections import deque

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

# Function to insert element 
# in binary tree
def InsertNode(root, data):
  
    # If the tree is empty, assign new
    # node address to root
    if root is None:
        root = Node(data)
        return root

    # Else, do level order traversal until we find an empty
    # place, i.e. either left child or right child of some
    # node is pointing to NULL.
    q = deque()
    q.append(root)

    while q:
      
        # Fron a front element 
        # in queue
        curr = q.popleft()

        # First check left if left is null 
        # insert node in left otherwise check
        # for right
        if curr.left is not None:
            q.append(curr.left)
        else:
            curr.left = Node(data)
            return root

        if curr.right is not None:
            q.append(curr.right)
        else:
            curr.right = Node(data)
            return root

# Inorder traversal of a binary tree
def inorder(curr):
    if curr is None:
        return
    inorder(curr.left)
    print(curr.data, end=' ')
    inorder(curr.right)

if __name__ == "__main__":
  
    # Constructing the binary tree
    #          10
    #        /    \ 
    #       11     9
    #      /      / \
    #     7      15   8
    root = Node(10)
    root.left = Node(11)
    root.right = Node(9)
    root.left.left = Node(7)
    root.right.left = Node(15)
    root.right.right = Node(8)

    key = 12
    root = InsertNode(root, key)

    # After insertion 12 in binary tree
    #          10
    #        /    \ 
    #       11     9
    #      /  \   / \
    #     7   12 15  8
    inorder(root)

// C# program to insert element (in level order)
// in Binary Tree
using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {
  
    // Function to insert element in binary tree
    static Node InsertNode(Node root, int data) {
      
        // If the tree is empty, assign new node
      	// address to root
        if (root == null) {
            root = new Node(data);
            return root;
        }

        // Else, do level order traversal until we find an empty
        // place, i.e. either left child or right child of some
        // node is pointing to NULL.
        Queue<Node> q = new Queue<Node>();
        q.Enqueue(root);

        while (q.Count > 0) {
          
            // Fron a front element in queue
            Node curr = q.Dequeue();

            // First check left if left is null
          	// insert node in left otherwise check 
          	// for right
            if (curr.left != null)
                q.Enqueue(curr.left);
            else {
                curr.left = new Node(data);
                return root;
            }

            if (curr.right != null)
                q.Enqueue(curr.right);
            else {
                curr.right = new Node(data);
                return root;
            }
        }
        return root;
    }

    // Inorder traversal of a binary tree
    static void inorder(Node curr) {
        if (curr == null)
            return;
        inorder(curr.left);
        Console.Write(curr.data + " ");
        inorder(curr.right);
    }

    static void Main(string[] args) {
      
        // Constructing the binary tree
        //          10
        //        /    \ 
        //       11     9
        //      /      / \
        //     7      15   8
        Node root = new Node(10);
        root.left = new Node(11);
        root.right = new Node(9);
        root.left.left = new Node(7);
        root.right.left = new Node(15);
        root.right.right = new Node(8);

        int key = 12;
        root = InsertNode(root, key);

        // After insertion 12 in binary tree
        //          10
        //        /    \ 
        //       11     9
        //      /  \   / \
        //     7   12 15  8
        inorder(root);
    }
}

JavaScript

// JavaScript program to insert element 
// (in level order) in Binary Tree

class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// Function to insert element in binary tree
function InsertNode(root, data) {

    // If the tree is empty, assign new
    // node address to root
    if (root == null) {
        root = new Node(data);
        return root;
    }

    // Else, do level order traversal until we find an empty
    // place, i.e. either left child or right child of some
    // node is pointing to NULL.
    let q = [];
    q.push(root);

    while (q.length > 0) {
    
        let curr = q.shift();

        // First check left if left is null 
        // insert node in left otherwise chaeck for right
        if (curr.left !== null)
            q.push(curr.left);
        else {
            curr.left = new Node(data);
            return root;
        }

        if (curr.right !== null)
            q.push(curr.right);
        else {
            curr.right = new Node(data);
            return root;
        }
    }
}

// Inorder traversal of a binary tree
function inorder(curr) {
    if (curr == null) return;
    inorder(curr.left);
    process.stdout.write(curr.data + ' ');
    inorder(curr.right);
}

// Constructing the binary tree
//          10
//        /    \ 
//       11     9
//      /      / \
//     7      15   8
let root = new Node(10);
root.left = new Node(11);
root.right = new Node(9);
root.left.left = new Node(7);
root.right.left = new Node(15);
root.right.right = new Node(8);

let key = 12;
root = InsertNode(root, key);

// After insertion 12 in binary tree
//          10
//        /    \ 
//       11     9
//      /  \   / \
//     7   12 15  8

inorder(root);

Output

7 11 12 10 15 9 8

Time Complexity: O(n) where n is the number of nodes.
Auxiliary Space: O(n)

Deletion in a Binary Tree

Yash Singla

Improve

Article Tags :

Practice Tags :

Insertion in a Binary Tree in level order

Similar Reads

Types of Binary Tree

Thank You!

What kind of Experience do you want to share?