Skip to content

Complete Interview Preparation at 20% off | Use code: PREPAREKARO Check Now

Related Articles

Related Articles

Modify a Binary Tree by adding a level of nodes with given value at a specified level

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Hard
  • Last Updated : 25 Mar, 2022

Given a Binary Tree consisting of N nodes and two integers K and L, the task is to add one row of nodes of value K at the Lth level, such that the orientation of the original tree remains unchanged.

Examples:

Input: K = 1, L = 2

Output:
1
1 1
2 3
4 5 6 
Explanation:
Below is the tree after inserting node with value 1 in the K(= 2) th level.

Input: K = 1, L = 1

Output:
1
1
2 3
4 5 6 

Approach: The given problem can be solved by using Breadth First search for traversal of the tree and adding nodes with a given value between a node at level (L – 1) and roots of its left and right subtree. Follow the steps below to solve the problem:

  • If L is 1 then make the new node with value K then join the current root to the left of the new node making the new node the root node.
  • Initialize a Queue, say Q which is used to traverse the tree using BFS.
  • Initialize a variable, say CurrLevel that stores the current level of a node.
  • Iterate while Q is not empty() and CurrLevel is less than (L – 1) and perform the following steps:
    • Store the size of queue Q in a variable say len.
    • Iterate while len is greater than 0 and then pop the front element of the queue and push the left and the right subtree in Q.
    • Increment the value of CurrLevel by 1.
  • Now again iterate while Q is not empty() and perform the following steps:
    • Store the front node of Q in a variable say temp and pop the front element.
    • Store the left and the right subtree of temp node in variables, say temp1 and temp2 respectively.
    • Create a new node with value K and then join the current node to the left of node temp by assigning the node value to temp.left.
    • Again create a new node with value K and then join the current node to the right of node temp by assigning the node value to temp.right.
    • Then join the temp1 to the left of the new node i.e., temp.left.left and temp2 to the right of the new node i.e., temp.right.right.
  • After completing the above steps, print the tree in level order traversal.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
 
using namespace std;
 
// Class of TreeNode
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    
  // Constructor
    TreeNode(int v)
    {
        val = v;
        left = right = NULL;
    }
};
 
// Function to add one row to a
// binary tree
TreeNode *addOneRow(TreeNode *root, int K, int L)
{
    // If L is 1
    if (L == 1) {
 
        // Store the node having
        // the value K
        TreeNode *t = new TreeNode(K);
 
        // Join node t with the
        // root node
        t->left = root;
        return t;
    }
 
    // Stores the current Level
    int currLevel = 1;
 
    // For performing BFS traversal
    queue<TreeNode*> Q;
 
    // Add root node to Queue Q
    Q.push(root);
 
    // Traversal while currLevel
    // is less than L - 1
    while (Q.size() > 0 && currLevel < L - 1)
    {
 
        // Stores the count of the
        // total nodes at the
        // currLevel
        int len = Q.size();
 
        // Iterate while len
        // is greater than 0
        while (len > 0)
        {
 
            // Pop the front
            // element of Q
            TreeNode *node = Q.front();
            Q.pop();
 
            // If node.left is
            // not NULL
            if (node->left != NULL)
                Q.push(node->left);
 
            // If node.right is
            // not NULL
            if (node->right != NULL)
                Q.push(node->right);
 
            // Decrement len by 1
            len--;
        }
 
        // Increment currLevel by 1
        currLevel++;
    }
 
    // Iterate while Q is
    // non empty()
    while (Q.size() > 0)
    {
 
        // Stores the front node
        // of the Q queue
        TreeNode *temp = Q.front();
        Q.pop();
 
        // Stores its left sub-tree
        TreeNode *temp1 = temp->left;
 
        // Create a new Node with
        // value K and assign to
        // temp.left
        temp->left = new TreeNode(K);
 
        // Assign temp1 to the
        // temp.left.left
        temp->left->left = temp1;
 
        // Store its right subtree
        TreeNode *temp2 = temp->right;
 
        // Create a new Node with
        // value K and assign to
        // temp.right
        temp->right = new TreeNode(K);
 
        // Assign temp2 to the
        // temp.right.right
        temp->right->right = temp2;
    }
 
    // Return the updated root
    return root;
}
 
// Function to print the tree in
// the level order traversal
void levelOrder(TreeNode *root)
{
    queue<TreeNode*> Q;
 
    if (root == NULL) {
        cout<<("Null")<<endl;
        return;
    }
 
    // Add root node to Q
    Q.push(root);
 
    while (Q.size() > 0) {
 
        // Stores the total nodes
        // at current level
        int len = Q.size();
 
        // Iterate while len
        // is greater than 0
        while (len > 0) {
 
            // Stores the front Node
            TreeNode *temp = Q.front();
            Q.pop();
 
            // Print the value of
            // the current node
            cout << temp->val << " ";
 
            // If reference to left
            // subtree is not NULL
            if (temp->left != NULL)
 
                // Add root of left
                // subtree to Q
                Q.push(temp->left);
 
            // If reference to right
            // subtree is not NULL
            if (temp->right != NULL)
 
                // Add root of right
                // subtree to Q
                Q.push(temp->right);
 
            // Decrement len by 1
            len--;
        }
 
        cout << endl;
    }
}
 
// Driver Code
int main()
{
   
    // Given Tree
    TreeNode *root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right = new TreeNode(3);
    root->right->right = new TreeNode(6);
 
    int L = 2;
    int K = 1;
 
    levelOrder(addOneRow(root, K, L));
}
 
// This code is contributed by mohit kumar 29.

Java



// Java program for the above approach
 
import java.io.*;
import java.util.*;
 
class GFG {
 
    // Class of TreeNode
    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
 
        // Constructor
        TreeNode(int val)
        {
            this.val = val;
        }
    }
 
    // Function to add one row to a
    // binary tree
    public static TreeNode addOneRow(
        TreeNode root, int K, int L)
    {
        // If L is 1
        if (L == 1) {
 
            // Store the node having
            // the value K
            TreeNode t = new TreeNode(K);
 
            // Join node t with the
            // root node
            t.left = root;
            return t;
        }
 
        // Stores the current Level
        int currLevel = 1;
 
        // For performing BFS traversal
        Queue<TreeNode> Q
            = new LinkedList<TreeNode>();
 
        // Add root node to Queue Q
        Q.add(root);
 
        // Traversal while currLevel
        // is less than L - 1
        while (!Q.isEmpty()
               && currLevel < L - 1) {
 
            // Stores the count of the
            // total nodes at the
            // currLevel
            int len = Q.size();
 
            // Iterate while len
            // is greater than 0
            while (len > 0) {
 
                // Pop the front
                // element of Q
                TreeNode node = Q.poll();
 
                // If node.left is
                // not null
                if (node.left != null)
                    Q.add(node.left);
 
                // If node.right is
                // not null
                if (node.right != null)
                    Q.add(node.right);
 
                // Decrement len by 1
                len--;
            }
 
            // Increment currLevel by 1
            currLevel++;
        }
 
        // Iterate while Q is
        // non empty()
        while (!Q.isEmpty()) {
 
            // Stores the front node
            // of the Q queue
            TreeNode temp = Q.poll();
 
            // Stores its left sub-tree
            TreeNode temp1 = temp.left;
 
            // Create a new Node with
            // value K and assign to
            // temp.left
            temp.left = new TreeNode(K);
 
            // Assign temp1 to the
            // temp.left.left
            temp.left.left = temp1;
 
            // Store its right subtree
            TreeNode temp2 = temp.right;
 
            // Create a new Node with
            // value K and assign to
            // temp.right
            temp.right = new TreeNode(K);
 
            // Assign temp2 to the
            // temp.right.right
            temp.right.right = temp2;
        }
 
        // Return the updated root
        return root;
    }
 
    // Function to print the tree in
    // the level order traversal
    public static void levelOrder(
        TreeNode root)
    {
        Queue<TreeNode> Q
            = new LinkedList<>();
 
        if (root == null) {
            System.out.println("Null");
            return;
        }
 
        // Add root node to Q
        Q.add(root);
 
        while (!Q.isEmpty()) {
 
            // Stores the total nodes
            // at current level
            int len = Q.size();
 
            // Iterate while len
            // is greater than 0
            while (len > 0) {
 
                // Stores the front Node
                TreeNode temp = Q.poll();
 
                // Print the value of
                // the current node
                System.out.print(
                    temp.val + " ");
 
                // If reference to left
                // subtree is not null
                if (temp.left != null)
 
                    // Add root of left
                    // subtree to Q
                    Q.add(temp.left);
 
                // If reference to right
                // subtree is not null
                if (temp.right != null)
 
                    // Add root of right
                    // subtree to Q
                    Q.add(temp.right);
 
                // Decrement len by 1
                len--;
            }
 
            System.out.println();
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        // Given Tree
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        root.right = new TreeNode(3);
        root.right.right = new TreeNode(6);
 
        int L = 2;
        int K = 1;
 
        levelOrder(addOneRow(root, K, L));
    }
}
Python3



# Python program for the above approach
 
# Class of TreeNode
class TreeNode:
 
    def __init__(self, val):
     
        self.val = val
        self.left,self.right = None,None
     
# Function to add one row to a
    # binary tree
def addOneRow(root,K,L):
     
    # If L is 1
        if (L == 1):
  
            # Store the node having
            # the value K
            t = TreeNode(K)
  
            # Join node t with the
            # root node
            t.left = root
            return t
  
        # Stores the current Level
        currLevel = 1
  
        # For performing BFS traversal
        Q =[]
             
        # Add root node to Queue Q
        Q.append(root)
  
        # Traversal while currLevel
        # is less than L - 1
        while (len(Q)!=0 and currLevel < L - 1):
  
            # Stores the count of the
            # total nodes at the
            # currLevel
            Len = len(Q)
  
            # Iterate while len
            # is greater than 0
            while (Len > 0):
  
                # Pop the front
                # element of Q
                node = Q[0]
                Q = Q[1:]
  
                # If node.left is
                # not None
                if (node.left != None):
                    Q.append(node.left)
  
                # If node.right is
                # not None
                if (node.right != None):
                    Q.append(node.right)
  
                # Decrement len by 1
                Len -= 1
  
            # Increment currLevel by 1
            currLevel += 1
  
        # Iterate while Q is
        # non empty()
        while (len(Q)!=0):
  
            # Stores the front node
            # of the Q queue
            temp = Q[0]
            Q = Q[1:]
  
            # Stores its left sub-tree
            temp1 = temp.left
  
            # Create a Node with
            # value K and assign to
            # temp.left
            temp.left = TreeNode(K)
  
            # Assign temp1 to the
            # temp.left.left
            temp.left.left = temp1
  
            # Store its right subtree
            temp2 = temp.right
  
            # Create a Node with
            # value K and assign to
            # temp.right
            temp.right = TreeNode(K)
  
            # Assign temp2 to the
            # temp.right.right
            temp.right.right = temp2
  
        # Return the updated root
        return root
 
# Function to print the tree in
    # the level order traversal
def levelOrder(root):
 
    Q = []
  
    if (root == None):
        print("Null")
        return
  
    # Add root node to Q
    Q.append(root)
  
    while (len(Q)!=0):
  
        # Stores the total nodes
        # at current level
        Len = len(Q)
  
        # Iterate while len
        # is greater than 0
        while (Len > 0):
  
            # Stores the front Node
            temp = Q[0]
            Q = Q[1:]
  
            # Print the value of
            # the current node
            print(temp.val,end=" ")
  
            # If reference to left
            # subtree is not null
            if (temp.left != None):
  
                # Add root of left
                # subtree to Q
                Q.append(temp.left)
  
            # If reference to right
            # subtree is not null
            if (temp.right != None):
  
                # Add root of right
                # subtree to Q
                Q.append(temp.right)
  
            # Decrement len by 1
            Len -= 1
  
        print()
 
# Driver Code
root = TreeNode(1)
root.left = TreeNode(2)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right = TreeNode(3)
root.right.right = TreeNode(6)
 
L = 2
K = 1
 
levelOrder(addOneRow(root, K, L))
 
# This code is contributed by shinjanpatra
Javascript



<script>
 
// JavaScript program for the above approach
 
// Class of TreeNode
class TreeNode
{
    constructor(val)
    {
        this.val=val;
        this.left=this.right=null;
    }
}
 
// Function to add one row to a
    // binary tree
function addOneRow(root,K,L)
{
    // If L is 1
        if (L == 1) {
  
            // Store the node having
            // the value K
            let t = new TreeNode(K);
  
            // Join node t with the
            // root node
            t.left = root;
            return t;
        }
  
        // Stores the current Level
        let currLevel = 1;
  
        // For performing BFS traversal
        let Q =[];
             
  
        // Add root node to Queue Q
        Q.push(root);
  
        // Traversal while currLevel
        // is less than L - 1
        while (Q.length!=0
               && currLevel < L - 1) {
  
            // Stores the count of the
            // total nodes at the
            // currLevel
            let len = Q.length;
  
            // Iterate while len
            // is greater than 0
            while (len > 0) {
  
                // Pop the front
                // element of Q
                let node = Q.shift();
  
                // If node.left is
                // not null
                if (node.left != null)
                    Q.push(node.left);
  
                // If node.right is
                // not null
                if (node.right != null)
                    Q.push(node.right);
  
                // Decrement len by 1
                len--;
            }
  
            // Increment currLevel by 1
            currLevel++;
        }
  
        // Iterate while Q is
        // non empty()
        while (Q.length!=0) {
  
            // Stores the front node
            // of the Q queue
            let temp = Q.shift();
  
            // Stores its left sub-tree
            let temp1 = temp.left;
  
            // Create a new Node with
            // value K and assign to
            // temp.left
            temp.left = new TreeNode(K);
  
            // Assign temp1 to the
            // temp.left.left
            temp.left.left = temp1;
  
            // Store its right subtree
            let temp2 = temp.right;
  
            // Create a new Node with
            // value K and assign to
            // temp.right
            temp.right = new TreeNode(K);
  
            // Assign temp2 to the
            // temp.right.right
            temp.right.right = temp2;
        }
  
        // Return the updated root
        return root;
}
 
// Function to print the tree in
    // the level order traversal
function levelOrder(root)
{
    let Q= [];
  
        if (root == null) {
            document.write("Null<br>");
            return;
        }
  
        // Add root node to Q
        Q.push(root);
  
        while (Q.length!=0) {
  
            // Stores the total nodes
            // at current level
            let len = Q.length;
  
            // Iterate while len
            // is greater than 0
            while (len > 0) {
  
                // Stores the front Node
                let temp = Q.shift();
  
                // Print the value of
                // the current node
                document.write(
                    temp.val + " ");
  
                // If reference to left
                // subtree is not null
                if (temp.left != null)
  
                    // Add root of left
                    // subtree to Q
                    Q.push(temp.left);
  
                // If reference to right
                // subtree is not null
                if (temp.right != null)
  
                    // Add root of right
                    // subtree to Q
                    Q.push(temp.right);
  
                // Decrement len by 1
                len--;
            }
  
            document.write("<br>");
        }
}
 
// Driver Code
let root = new TreeNode(1);
root.left = new TreeNode(2);
root.left.left = new TreeNode(4);
root.left.right = new TreeNode(5);
root.right = new TreeNode(3);
root.right.right = new TreeNode(6);
 
let L = 2;
let K = 1;
 
levelOrder(addOneRow(root, K, L));
 
 
// This code is contributed by unknown2108
 
</script>
Output: 
1 
1 1 
2 3 
4 5 6
 
Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes
arrow_drop_up
Previous
Google Cloud Platform - Query History vs Saved Query vs Shared Query in BigQuery
Next

Maximum Bitwise XOR of node values of an Acyclic Graph made up of N given vertices using M edges
Recommended Articles
Page :
Print the nodes corresponding to the level value for each level of a Binary Tree
12, Oct 20
Convert given Binary Tree to Symmetric Tree by adding minimum number of nodes
15, Oct 21
Count nodes from all lower levels smaller than minimum valued node of current level for every level in a Binary Tree
14, Sep 20
Difference between sums of odd level and even level nodes of a Binary Tree
19, Aug 13
Print nodes of a Binary Search Tree in Top Level Order and Reversed Bottom Level Order alternately
21, Sep 20
Queries to find the maximum Xor value between X and the nodes of a given level of a perfect binary tree
15, May 19
Modify Binary Tree by replacing each node with nearest power of minimum of previous level
06, Apr 21
Minimum value to be added at each level in Binary Tree to make all level sum equal
24, Aug 21
Modify Binary Tree by replacing all nodes at even and odd levels by their nearest even or odd perfect squares respectively
22, Feb 21
Modify a Binary Tree by shifting all nodes to as far right as possible
22, Feb 21
Modify Binary Tree by replacing each node with the product of all remaining nodes
13, May 21
Difference between sums of odd level and even level nodes in an N-ary Tree
07, Sep 20
Calculate sum of all nodes present in a level for each level of a Tree
05, Feb 21
Difference between odd level and even level leaf sum in given Binary Tree
28, Jan 22
Print odd positioned nodes of odd levels in level order of the given binary tree
05, Sep 19
Print even positioned nodes of even levels in level order of the given binary tree
29, Apr 19
Print all the nodes except the leftmost node in every level of the given binary tree
29, May 19
Print even positioned nodes of odd levels in level order of the given binary tree
06, Sep 19
Print odd positioned nodes of even levels in level order of the given binary tree
06, Sep 19
Print all Nodes of given Binary Tree at the Kth Level
02, Feb 22
Print nodes between two given level numbers of a binary tree
19, Oct 14
Print extreme nodes of each level of Binary Tree in alternate order
22, Jul 16
Swap Nodes in Binary tree of every k'th level
30, Nov 16
Count nodes with two children at level L in a Binary Tree
22, Mar 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
gireeshgudaparthi
@gireeshgudaparthi
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!