Modify a Binary Tree by adding a level of nodes with given value at a specified level
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++
// 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
// 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
#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 |
C#
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
// 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++
// 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)); } |
Java
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
# 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)); |
C#
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
// 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.
C++14
#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)); } |
Java
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)); } } |
Python3
# 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)) |
C#
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 |
Javascript
// 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)
Please Login to comment...