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 1: 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++ 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 val, int depth) {
queue<TreeNode*> q;
if (depth==1)
{
TreeNode* rt= new TreeNode(val);
rt->left=root;
return rt;
}
int c=1;
q.push(root);
while (!q.empty() && c<depth)
{
int a=q.size();
c++;
for ( int i=0;i<a;i++)
{
auto k=q.front();
q.pop();
if (c==depth)
{
if (k->left!=nullptr)
{
TreeNode* tm = new TreeNode(val);
TreeNode* t=k->left;
k->left= tm ;
tm ->left=t;
}
else
{
TreeNode* tm = new TreeNode(val);
k->left= tm ;
}
if (k->right!=nullptr)
{
TreeNode* tm = new TreeNode(val);
TreeNode* t=k->right;
k->right= tm ;
tm ->right=t;
}
else {
TreeNode* tm = new TreeNode(val);
k->right= tm ;
}
}
else
{
if (k->left!=nullptr)
q.push(k->left);
if (k->right!=nullptr)
q.push(k->right);
}
}
}
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));
} |
// Java program for the above approach import java.util.LinkedList;
import java.util.Queue;
public class Main {
static class 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
public static TreeNode addOneRow(TreeNode root, int val,
int depth)
{
Queue<TreeNode> q = new LinkedList<>();
if (depth == 1 ) {
TreeNode rt = new TreeNode(val);
rt.left = root;
return rt;
}
int c = 1 ;
q.offer(root);
while (!q.isEmpty() && c < depth) {
int a = q.size();
c++;
for ( int i = 0 ; i < a; i++) {
TreeNode k = q.poll();
if (c == depth) {
if (k.left != null ) {
TreeNode tm = new TreeNode(val);
TreeNode t = k.left;
k.left = tm;
tm.left = t;
}
else {
TreeNode tm = new TreeNode(val);
k.left = tm;
}
if (k.right != null ) {
TreeNode tm = new TreeNode(val);
TreeNode t = k.right;
k.right = tm;
tm.right = t;
}
else {
TreeNode tm = new TreeNode(val);
k.right = tm;
}
}
else {
if (k.left != null )
q.offer(k.left);
if (k.right != null )
q.offer(k.right);
}
}
}
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.offer(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.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.offer(temp.left);
// If reference to right
// subtree is not NULL
if (temp.right != null )
// Add root of right
// subtree to Q
Q.offer(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 code for the above approach # Class of TreeNode class TreeNode:
def __init__( self , v):
self .val = v
self .left = None
self .right = None
# Function to add one row to a # binary tree def addOneRow(root, val, depth):
q = []
if depth = = 1 :
rt = TreeNode(val)
rt.left = root
return rt
c = 1
q.append(root)
while q and c < depth:
a = len (q)
c + = 1
for i in range (a):
k = q[ 0 ]
q.pop( 0 )
if c = = depth:
if k.left is not None :
tm = TreeNode(val)
t = k.left
k.left = tm
tm.left = t
else :
tm = TreeNode(val)
k.left = tm
if k.right is not None :
tm = TreeNode(val)
t = k.right
k.right = tm
tm.right = t
else :
tm = TreeNode(val)
k.right = tm
else :
if k.left is not None :
q.append(k.left)
if k.right is not None :
q.append(k.right)
return root
# Function to print the tree in # the level order traversal def levelOrder(root):
Q = []
if root is 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.pop( 0 )
# Print the value of the current node
print (temp.val, end = " " )
# If reference to left subtree is not None
if temp.left is not None :
# Add root of left subtree to Q
Q.append(temp.left)
# If reference to right subtree is not None
if temp.right is not None :
# Add root of right subtree to Q
Q.append(temp.right)
# Decrement len by 1
len_ - = 1
print ()
# Driver Code
if __name__ = = "__main__" :
# Given Tree
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 Potta Lokesh |
using System;
using System.Collections.Generic;
public class MainClass
{ public class TreeNode
{
public int val;
public TreeNode left;
public TreeNode right;
// Constructor
public TreeNode( int v)
{
val = v;
left = right = null ;
}
}
// Function to add one row to a binary tree
public static TreeNode AddOneRow(TreeNode root, int val, int depth)
{
Queue<TreeNode> q = new Queue<TreeNode>();
if (depth == 1)
{
TreeNode rt = new TreeNode(val);
rt.left = root;
return rt;
}
int c = 1;
q.Enqueue(root);
while (q.Count > 0 && c < depth)
{
int a = q.Count;
c++;
for ( int i = 0; i < a; i++)
{
TreeNode k = q.Dequeue();
if (c == depth)
{
if (k.left != null )
{
TreeNode tm = new TreeNode(val);
TreeNode t = k.left;
k.left = tm;
tm.left = t;
}
else
{
TreeNode tm = new TreeNode(val);
k.left = tm;
}
if (k.right != null )
{
TreeNode tm = new TreeNode(val);
TreeNode t = k.right;
k.right = tm;
tm.right = t;
}
else
{
TreeNode tm = new TreeNode(val);
k.right = tm;
}
}
else
{
if (k.left != null )
q.Enqueue(k.left);
if (k.right != null )
q.Enqueue(k.right);
}
}
}
return root;
}
// Function to print the tree in the level order traversal
public static void LevelOrder(TreeNode root)
{
Queue<TreeNode> Q = new Queue<TreeNode>();
if (root == null )
{
Console.WriteLine( "Null" );
return ;
}
// Add root node to Q
Q.Enqueue(root);
while (Q.Count > 0)
{
// Stores the total nodes at current level
int len = Q.Count;
// Iterate while len is greater than 0
while (len > 0)
{
// Stores the front Node
TreeNode temp = Q.Dequeue();
// Print the value of the current node
Console.Write(temp.val + " " );
// If reference to left subtree is not NULL
if (temp.left != null )
// Add root of left subtree to Q
Q.Enqueue(temp.left);
// If reference to right subtree is not NULL
if (temp.right != null )
// Add root of right subtree to Q
Q.Enqueue(temp.right);
// Decrement len by 1
len--;
}
Console.WriteLine();
}
}
// Driver Code
public static void 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));
}
} |
// JavaScript program for the above approach // class of TreeNode class TreeNode{ constructor(v){
this .val = v;
this .left = null ;
this .right = null ;
}
} // function to add one row to a binary tree function addOneRow(root, val, depth){
q = [];
if (depth == 1){
let rt = new TreeNode(val);
rt.left = root;
return rt;
}
let c = 1;
q.push(root);
while (q.length > 0 && c < depth){
let a = q.length;
c++;
for (let i = 0; i<a; i++){
let k = q.shift();
if (c == depth){
if (k.left != null ){
let tm = new TreeNode(val);
let t = k.left;
k.left = tm;
tm.left = t;
}
else {
let tm = new TreeNode(val);
k.left = tm;
}
if (k.right != null ){
let tm = new TreeNode(val);
let t = k.right;
k.right = tm;
tm.right = t;
}
else {
let tm = new TreeNode(val);
k.right = tm;
}
}
else {
if (k.left != null )
q.push(k.left);
if (k.right != null )
q.push(k.right);
}
}
}
return root;
} // function to print the tree in // the level order traversal function levelOrder(root)
{ Q = [];
if (root == null ){
console.log( "NULL" );
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
console.log(temp.val + " " );
// if reference to left subtree is not null
if (temp.left != null )
{
// add root of right 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--;
}
}
} // 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 Yash Agarwal(yashagarwal2852002) |
1 1 1 2 3 4 5 6
Time Complexity: O(N)
Auxiliary Space: O(N)
Approach 2: The given problem can also be solved by using Depth 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.
- Make the initial DFS call for root node by passing the current level equal to 1.
- Check if the current level is equal to desired depth minus one, that is if it is one level before the desired level L (depth is equal to L-1) then:
- Create a node tmp with val K and make tmp.left = cur.left and cur.left = tmp.
- Create a node tmp with val K and make tmp.right = cur.right and cur.right= tmp.
- Make recursive dfs calls for left and right subtree by incrementing the level by 1.
- Print the tree in level order traversal.
Below is the implementation of the above approach:
// 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;
}
}; void dfsUtil(TreeNode* root, int level, int L, int K){
// base condition
if (root==NULL)
return ;
// when the parent of desired level
// is reached in traversal
if (level == L-1){
// Create a new Node tmp with
// value K and assign its left
// to root.left and root.left to tmp
TreeNode* tmp = new TreeNode(K);
tmp->left = root->left;
root->left = tmp;
// Create another Node tmp1 with
// value K and assign its left
// to root.left and root.left to tmp
TreeNode* tmp1 = new TreeNode(K);
tmp1->right = root->right;
root->right = tmp1;
return ;
}
/// make the recursive calls
// for left and right subtree by increasing level by 1
dfsUtil(root->left, level+1, L, K);
dfsUtil(root->right, level+1, L, K);
} // 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;
}
// Call dfs with val, depth and current level as 1
// for traversing and adding the nodes with
// given value at given level
dfsUtil(root, 1, L, K);
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));
} |
import java.util.*;
// Class of TreeNode class TreeNode
{ int val;
TreeNode left, right;
// Constructor
public TreeNode( int v)
{
val = v;
left = right = null ;
}
} class GfG
{ public static void dfsUtil(TreeNode root, int level, int L, int K)
{
// base condition
if (root == null )
{
return ;
}
// when the parent of desired level
// is reached in traversal
if (level == L - 1 )
{
// Create a new Node tmp with
// value K and assign its left
// to root.left and root.left to tmp
TreeNode tmp = new TreeNode(K);
tmp.left = root.left;
root.left = tmp;
// Create another Node tmp1 with
// value K and assign its left
// to root.left and root.left to tmp
TreeNode tmp1 = new TreeNode(K);
tmp1.right = root.right;
root.right = tmp1;
return ;
}
/// make the recursive calls
// for left and right subtree by increasing level by 1
dfsUtil(root.left, level + 1 , L, K);
dfsUtil(root.right, level + 1 , L, K);
}
// 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;
}
// Call dfs with val, depth and current level as 1
// for traversing and adding the nodes with
// given value at given level
dfsUtil(root, 1 , L, K);
return root;
}
// Function to print the tree in
// the level order traversal
public static void levelOrder(TreeNode root)
{
LinkedList<TreeNode> Q = new LinkedList<TreeNode>();
if (root == null )
{
System.out.print(( "Null" ));
System.out.print( "\n" );
return ;
}
// Add root node to Q
Q.offer(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.peek();
Q.poll();
// Print the value of
// the current node
System.out.print(temp.val);
System.out.print( " " );
// If reference to left
// subtree is not NULL
if (temp.left != null )
{
// Add root of left
// subtree to Q
Q.offer(temp.left);
}
// If reference to right
// subtree is not NULL
if (temp.right != null )
{
// Add root of right
// subtree to Q
Q.offer(temp.right);
}
// Decrement len by 1
len--;
}
System.out.print( "\n" );
}
}
// 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));
}
} // This code is contributed by ajaymakvana. |
# Python3 program for the above approach class TreeNode:
def __init__( self , v):
self .val = v
self .left = None
self .right = None
def dfs_util(root, level, L, K):
# base condition
if root is None :
return
# when the parent of desired level
# is reached in traversal
if level = = L - 1 :
# Create a new Node tmp with
# value K and assign its left
# to root.left and root.left to tmp
tmp = TreeNode(K)
tmp.left = root.left
root.left = tmp
# Create another Node tmp1 with
# value K and assign its left
# to root.left and root.left to tmp
tmp1 = TreeNode(K)
tmp1.right = root.right
root.right = tmp1
return
# make the recursive calls
# for left and right subtree by increasing level by 1
dfs_util(root.left, level + 1 , L, K)
dfs_util(root.right, level + 1 , L, K)
# Function to add one row to a # binary tree def add_one_row(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
# Call dfs with val, depth and current level as 1
# for traversing and adding the nodes with
# given value at given level
dfs_util(root, 1 , L, K)
return root
# Function to print the tree in # the level order traversal def level_order(root):
Q = []
if root is 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.pop( 0 )
# Print the value of
# the current node
print (temp.val, end = ' ' )
# If reference to left
# subtree is not NULL
if temp.left is not None :
# Add root of left
# subtree to Q
Q.append(temp.left)
# If reference to right
# subtree is not NULL
if temp.right is not None :
# Add root of right
# subtree to Q
Q.append(temp.right)
# Decrement len by 1
len_ - = 1
print ()
# Driver Code # Given Tree 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 ;
level_order(add_one_row(root, K, L)); |
using System;
using System.Collections.Generic;
// Class of TreeNode public class TreeNode {
public int val;
public TreeNode left;
public TreeNode right;
// Constructor
public TreeNode( int v)
{
val = v;
left = right = null ;
}
} public class Solution {
public void dfsUtil(TreeNode root, int level, int L,
int K)
{
// base condition
if (root == null ) {
return ;
}
// when the parent of desired level
// is reached in traversal
if (level == L - 1) {
// Create a new Node tmp with
// value K and assign its left
// to root.left and root.left to tmp
TreeNode tmp = new TreeNode(K);
tmp.left = root.left;
root.left = tmp;
// Create another Node tmp1 with
// value K and assign its left
// to root.left and root.left to tmp
TreeNode tmp1 = new TreeNode(K);
tmp1.right = root.right;
root.right = tmp1;
return ;
}
/// make the recursive calls
// for left and right subtree by increasing level by
// 1
dfsUtil(root.left, level + 1, L, K);
dfsUtil(root.right, level + 1, L, K);
}
// Function to add one row to a
// binary tree
public 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;
}
// Call dfs with val, depth and current level as 1
// for traversing and adding the nodes with
// given value at given level
dfsUtil(root, 1, L, K);
return root;
}
// Function to print the tree in
// the level order traversal
public void LevelOrder(TreeNode root)
{
Queue<TreeNode> Q = new Queue<TreeNode>();
if (root == null ) {
Console.WriteLine( "Null" );
return ;
}
// Add root node to Q
Q.Enqueue(root);
while (Q.Count > 0) {
// Stores the total nodes
// at current level
int len = Q.Count;
// Iterate while len
// is greater than 0
while (len > 0) {
// Stores the front Node
TreeNode temp = Q.Dequeue();
Console.Write(temp.val + " " );
// Print the value of
// the current node
if (temp.left != null ) {
// If reference to right
// subtree is not NULL
Q.Enqueue(temp.left);
}
if (temp.right != null ) {
// Add root of right
// subtree to Q
Q.Enqueue(temp.right);
}
len--;
}
Console.WriteLine();
}
}
public static void Main()
{
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;
Solution s = new Solution();
s.LevelOrder(s.AddOneRow(root, K, L));
}
} |
// JavaScript program for the above approach class TreeNode { constructor(v) {
this .val = v;
this .left = null ;
this .right = null ;
}
} function dfsUtil(root, level, L, K) {
// base condition
if (root == null )
return ;
// when the parent of desired level
// is reached in traversal
if (level == L - 1) {
// Create a new Node tmp with
// value K and assign its left
// to root.left and root.left to tmp
let tmp = new TreeNode(K);
tmp.left = root.left;
root.left = tmp;
// Create another Node tmp1 with
// value K and assign its left
// to root.left and root.left to tmp
let tmp1 = new TreeNode(K);
tmp1.right = root.right;
root.right = tmp1;
return ;
}
/// make the recursive calls
// for left and right subtree by increasing level by 1
dfsUtil(root.left, level + 1, L, K);
dfsUtil(root.right, level + 1, L, K);
} // 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;
}
// Call dfs with val, depth and current level as 1
// for traversing and adding the nodes with
// given value at given level
dfsUtil(root, 1, L, K);
return root;
} // Function to print the tree in // the level order traversal function levelOrder(root) {
let Q = [];
if (root == null ) {
console.log( "Null" );
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
console.log(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--;
}
console.log( "\n" );
}
} // Driver Code // Given Tree 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 contributed by adityamaharshi21 |
1 1 1 2 3 4 5 6
Time Complexity: O(N)
Auxiliary Space: O(N)
Approach 3:
Using the stack.
#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;
}
}; TreeNode* addOneRow(TreeNode* root, int val, int depth)
{ // if depth is 1
if (depth == 1) {
// store the node having
// the value val
TreeNode* rt = new TreeNode(val);
// join node rt with the
// root node
rt->left = root;
return rt;
}
else {
// declare a stack of pair which will be storing
// the node and its respective level
stack<pair<TreeNode*, int > > st;
// push the root node and the level
st.push(make_pair(root, 1));
// repeat the process while the stack is not empty
while (!st.empty()) {
auto node = st.top().first;
auto level = st.top().second;
st.pop();
// if the node is nullptr then continue
if (!node)
continue ;
// if level is equal to the depth-1 then
if (level == depth - 1) {
// make a node with the value and make the
// connections
TreeNode* t = new TreeNode(val);
t->left = node->left;
node->left = t;
// make a node with the value and make the
// connections
TreeNode* p = new TreeNode(val);
p->right = node->right;
node->right = p;
continue ;
}
// push the node's left and node's right and
// there level in the stack correspondingly
st.push(make_pair(node->left, level + 1));
st.push(make_pair(node->right, level + 1));
}
}
// 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 ;
}
Q.push(root);
while (Q.size() > 0) {
int len = Q.size();
while (len > 0) {
TreeNode* temp = Q.front();
Q.pop();
cout << temp->val << " " ;
if (temp->left != NULL)
Q.push(temp->left);
if (temp->right != NULL)
Q.push(temp->right);
len--;
}
cout << endl;
}
} // Driver Code int main()
{ 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));
} |
import com.sun.source.tree.Tree;
import java.util.*;
class Pair
{ TreeNode first;
Integer second;
Pair(TreeNode first,Integer second)
{
this .first = first;
this .second = second;
}
} // Class of TreeNode class TreeNode {
int val;
TreeNode left;
TreeNode right;
// Constructor
TreeNode( int v) {
val = v;
left = right = null ;
}
} class Main {
public static TreeNode addOneRow(TreeNode root, int val, int depth) {
// if depth is 1
if (depth == 1 ) {
// store the node having the value val
TreeNode rt = new TreeNode(val);
// join node rt with the root node
rt.left = root;
return rt;
} else {
// declare a stack of pair which will be storing
// the node and its respective level
Stack<Pair> st = new Stack<>();
// push the root node and the level
st.push( new Pair(root, 1 ));
// repeat the process while the stack is not empty
while (!st.empty()) {
Pair pair = st.pop();
TreeNode node = pair.first;
int level = pair.second;
// if the node is null then continue
if (node == null )
continue ;
// if level is equal to the depth-1 then
if (level == depth - 1 ) {
// make a node with the value and make the
// connections
TreeNode t = new TreeNode(val);
t.left = node.left;
node.left = t;
// make a node with the value and make the
// connections
TreeNode p = new TreeNode(val);
p.right = node.right;
node.right = p;
continue ;
}
// push the node's left and node's right and
// their level in the stack correspondingly
st.push( new Pair(node.left, level + 1 ));
st.push( new Pair(node.right, level + 1 ));
}
}
// 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 ;
}
Q.add(root);
while (!Q.isEmpty()) {
int len = Q.size();
while (len > 0 ) {
TreeNode temp = Q.poll();
System.out.print(temp.val + " " );
if (temp.left != null )
Q.add(temp.left);
if (temp.right != null )
Q.add(temp.right);
len--;
}
System.out.println();
}
}
// Driver Code
public static void main(String[] args) {
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));
}
} |
# Class of TreeNode class TreeNode:
def __init__( self , v):
self .val = v
self .left = None
self .right = None
def addOneRow(root, val, depth):
# if depth is 1
if depth = = 1 :
# store the node having
# the value val
rt = TreeNode(val)
# join node rt with the
# root node
rt.left = root
return rt
else :
# declare a stack of pair which will be storing
# the node and its respective level
st = []
# push the root node and the level
st.append((root, 1 ))
# repeat the process while the stack is not empty
while st:
node, level = st.pop()
# if the node is None then continue
if not node:
continue
# if level is equal to the depth-1 then
if level = = depth - 1 :
# make a node with the value and make the
# connections
t = TreeNode(val)
t.left = node.left
node.left = t
# make a node with the value and make the
# connections
p = TreeNode(val)
p.right = node.right
node.right = p
continue
# push the node's left and node's right and
# their level in the stack correspondingly
st.append((node.left, level + 1 ))
st.append((node.right, level + 1 ))
# return the updated root
return root
# Function to print the tree in # the level order traversal def levelOrder(root):
if not root:
print ( "Null" )
return
Q = []
Q.append(root)
while Q:
len_Q = len (Q)
while len_Q > 0 :
temp = Q.pop( 0 )
print (temp.val, end = ' ' )
if temp.left:
Q.append(temp.left)
if temp.right:
Q.append(temp.right)
len_Q - = 1
print ()
# Driver Code if __name__ = = '__main__' :
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))
|
using System;
using System.Collections.Generic;
// Class of TreeNode public class TreeNode {
public int val;
public TreeNode left;
public TreeNode right;
// Constructor
public TreeNode( int v)
{
val = v;
left = right = null ;
}
} public class Solution {
public static TreeNode AddOneRow(TreeNode root, int val,
int depth)
{
// if depth is 1
if (depth == 1) {
// store the node having
// the value val
TreeNode rt = new TreeNode(val);
// join node rt with the
// root node
rt.left = root;
return rt;
}
else
{
// declare a stack of pair which will be storing
// the node and its respective level
Stack<(TreeNode, int )> st
= new Stack<(TreeNode, int )>();
// push the root node and the level
st.Push((root, 1));
// repeat the process while the stack is not
// empty
while (st.Count > 0) {
var (node, level) = st.Pop();
// if the node is null then continue
if (node == null )
continue ;
// if level is equal to the depth-1 then
if (level == depth - 1) {
// make a node with the value and make
// the connections
TreeNode t = new TreeNode(val);
t.left = node.left;
node.left = t;
// make a node with the value and make
// the connections
TreeNode p = new TreeNode(val);
p.right = node.right;
node.right = p;
continue ;
}
// push the node's left and node's right and
// their level in the stack correspondingly
st.Push((node.left, level + 1));
st.Push((node.right, level + 1));
}
}
// 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 Queue<TreeNode>();
if (root == null ) {
Console.WriteLine( "Null" );
return ;
}
Q.Enqueue(root);
while (Q.Count > 0) {
int len = Q.Count;
while (len > 0) {
TreeNode temp = Q.Dequeue();
Console.Write(temp.val + " " );
if (temp.left != null )
Q.Enqueue(temp.left);
if (temp.right != null )
Q.Enqueue(temp.right);
len--;
}
Console.WriteLine();
}
}
// Driver Code
public static void Main( string [] args)
{
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 Prajwal Kandekar |
// Class of TreeNode class TreeNode { constructor(val) {
this .val = val;
this .left = null ;
this .right = null ;
}
} function addOneRow(root, val, depth) {
// if depth is 1
if (depth === 1) {
// store the node having
// the value val
const rt = new TreeNode(val);
// join node rt with the
// root node
rt.left = root;
return rt;
} else {
// declare a queue which will be storing
// the node and its respective level
const q = [];
// push the root node and the level
q.push([root, 1]);
// repeat the process while the queue is not empty
while (q.length > 0) {
const [node, level] = q.shift();
// if the node is null then continue
if (!node) continue ;
// if level is equal to the depth-1 then
if (level === depth - 1) {
// make a node with the value and make the
// connections
const t = new TreeNode(val);
t.left = node.left;
node.left = t;
// make a node with the value and make the
// connections
const p = new TreeNode(val);
p.right = node.right;
node.right = p;
continue ;
}
// push the node's left and node's right and
// their level in the queue correspondingly
q.push([node.left, level + 1]);
q.push([node.right, level + 1]);
}
}
// return the updated root
return root;
} // Function to print the tree in // the level order traversal function levelOrder(root) {
const q = [];
if (root == null ) {
console.log( "Null" );
return ;
}
q.push(root);
while (q.length > 0) {
const len = q.length;
let level = '' ;
for (let i = 0; i < len; i++) {
const temp = q.shift();
level += temp.val + ' ' ;
if (temp.left != null ) q.push(temp.left);
if (temp.right != null ) q.push(temp.right);
}
console.log(level);
}
} // Driver Code const 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);
const L = 2; const K = 1; levelOrder(addOneRow(root, K, L)); |
1 1 1 2 3 4 5 6
Time Complexity: O(N)
Auxiliary Space: O(N)