Given a binary tree, the task is to print the inorder traversal of the modified tree obtained after shifting all the nodes of the given tree to as far right as possible, while maintaining the relative ordering in each level.
Examples:
Input: Below is the given Tree:
1
/ \
2 3
/ \ \
4 5 6
Output: 2 4 1 5 3 6
Explanation: The tree obtained after shifting all nodes to far right is as follows:
1
/ \
2 3
\ / \
4 5 6Input: Below is the given Tree:
1
/
2
/ \
3 4
/ \
5 6
Output: 1 3 2 5 4 6
Explanation:
1
\
2
/ \
3 4
/ \
5 6
Approach: The idea to solve the given problem is to store the nodes of a level from right to left using a stack and existing nodes of the next level using a queue and connect the nodes at valid positions using Level Order Traversal. Follow the steps below to solve the problem:
- Initialize a stack S to store the sequence of nodes of a level of a Binary Tree from right to left.
- Initialize a queue Q to store the existing nodes of a level of a Binary Tree.
- If the right child of root exists, push it into queue Q. Vacate the right child.
- If the left child of root exists, push it into queue Q. Vacate the left child.
- Push root into the stack S.
- Perform Level Order Traversal on the Binary Tree and perform the following steps:
- If the right child of the node at the top of the stack is vacant, set the node at the front of the queue as the right child.
- Otherwise, repeat the above step for the left child. Pop the node from the top of the stack.
- Add the left and right child of the node at the front of the queue, into the queue.
- Store the sequence of nodes in the next level from right to left in the Stack.
- After completing the above steps, print the inorder traversal of the modified tree.
Below is the implementation of the above approach:
C++14
// C++ program for the above approach#include <bits/stdc++.h>using namespace std;// Structure of a Tree nodestruct TreeNode { int val = 0; TreeNode* left; TreeNode* right; // Constructor TreeNode(int x) { val = x; left = right = NULL; }};// Function to print Inorder// Traversal of a Binary Treevoid printTree(TreeNode* root){ if (!root) return; // Traverse left child printTree(root->left); // Print current node cout << root->val << " "; // Traverse right child printTree(root->right);}// Function to shift all nodes of the// given Binary Tree to as far as// right possibleTreeNode* shiftRight(TreeNode* root){ // If tree is empty if (!root) return NULL; stack<TreeNode*> st; queue<TreeNode*> q; // If right child exists if (root->right) q.push(root->right); root->right = NULL; // If left child exists if (root->left) q.push(root->left); root->left = NULL; // Push current node into stack st.push(root); while (!q.empty()) { // Count valid existing nodes // in current level int n = q.size(); stack<TreeNode*> temp; // Iterate existing nodes // in the current level while (n--) { // If no right child exists if (!st.top()->right) // Set the rightmost // vacant node st.top()->right = q.front(); // If no left child exists else { // Set rightmost vacant node st.top()->left = q.front(); // Remove the node as both // child nodes are occupied st.pop(); } // If r̥ight child exist if (q.front()->right) // Push into the queue q.push(q.front()->right); // Vacate right child q.front()->right = NULL; // If left child exists if (q.front()->left) // Push into the queue q.push(q.front()->left); // Vacate left child q.front()->left = NULL; // Add the node to stack to // maintain sequence of nodes // present in the level temp.push(q.front()); q.pop(); } while (!st.empty()) st.pop(); // Add nodes of the next // level into the stack st while (!temp.empty()) { st.push(temp.top()); temp.pop(); } } // Return the root of the // modified Tree return root;}// Driver Codeint main(){ TreeNode* root = new TreeNode(1); root->left = new TreeNode(2); root->right = new TreeNode(3); root->left->left = new TreeNode(4); root->left->right = new TreeNode(5); root->right->right = new TreeNode(6); // Function Call root = shiftRight(root); // Print the inOrder Traversal printTree(root); return 0;} |
Python3
# Python 3 program for the above approach# Structure of a Tree nodeclass TreeNode: def __init__(self,val): self.val = val self.left = None self.right = None# Function to print Inorder# Traversal of a Binary Treedef printTree(root): if (root == None): return # Traverse left child printTree(root.left) # Print current node print(root.val,end = " ") # Traverse right child printTree(root.right)# Function to shift all nodes of the# given Binary Tree to as far as# right possibledef shiftRight(root): # If tree is empty if (root == None): return None st = [] #stack q = [] # queue # If right child exists if (root.right): q.append(root.right) root.right = None # If left child exists if (root.left): q.append(root.left) root.left = None # Push current node into stack st.append(root) while (len(q) > 0): # Count valid existing nodes # in current level n = len(q) temp = [] # Iterate existing nodes # in the current level while (n > 0 and len(st) > 0 and len(q) > 0): # If no right child exists if (st[len(st) - 1].right == None): # Set the rightmost # vacant node st[len(st) - 1].right = q[0] # If no left child exists else: # Set rightmost vacant node st[len(st) - 1].left = q[0] # Remove the node as both # child nodes are occupied st = st[:-1] # If r̥ight child exist if (q[0].right): # Push into the queue q.append(q[0].right) # Vacate right child q[0].right = None # If left child exists if (q[0].left): # Push into the queue q.append(q[0].left) # Vacate left child q[0].left = None # Add the node to stack to # maintain sequence of nodes # present in the level temp.append(q[0]) q = q[1:] while (len(st) > 0): st = st[:-1] # Add nodes of the next # level into the stack st while(len(temp)>0): st.append(temp[len(temp)-1]) temp = temp[:-1] # Return the root of the # modified Tree return root# Driver Codeif __name__ == '__main__': root = TreeNode(1) root.left = TreeNode(2) root.right = TreeNode(3) root.left.left = TreeNode(4) root.left.right = TreeNode(5) root.right.right = TreeNode(6) # Function Call root = shiftRight(root) # Print the inOrder Traversal printTree(root) # This code is contributed by SURENDRA_GANGWAR. |
2 4 1 5 3 6
Time Complexity: O(N)
Auxiliary Space: O(N)
Approach 2: (Using hashmap)
1. Store the levels and corresponding tree nodes.
2.And then greedily assign the nodes first as a right child and then as left in pairs of 2.
C++
// CPP program for the above approach#include <bits/stdc++.h>#include <iostream>using namespace std;// Structure of a Tree nodestruct TreeNode { int val = 0; TreeNode* left; TreeNode* right; // Constructor TreeNode(int x) { val = x; left = right = NULL; }};// Function to print Inorder// Traversal of a Binary Treevoid printTree(TreeNode* root){ if (!root) return; // Traverse left child printTree(root->left); // Print current node cout << root->val << " "; // Traverse right child printTree(root->right);}void dfsit(TreeNode* rt, int key, map<int, vector<TreeNode*> >& mp){ if (!rt) { return; } mp[key].push_back(rt); dfsit(rt->right, key + 1, mp); dfsit(rt->left, key + 1, mp); rt->left = NULL; rt->right = NULL;}TreeNode* shiftRight(TreeNode* root){ TreeNode* tmp = root; map<int, vector<TreeNode*> > mp; int i = 0; dfsit(root, 0, mp); int n = mp.size(); TreeNode* cur = new TreeNode(-1); queue<TreeNode*> st; st.push(cur); while (i < n) { vector<TreeNode*> nd = mp[i]; int j = 0; queue<TreeNode*> tmp; while (j < nd.size()) { auto r = st.front(); st.pop(); r->right = nd[j]; tmp.push(nd[j]); j++; if (j < nd.size()) { r->left = nd[j]; tmp.push(nd[j]); j++; } } st = tmp; i++; } return cur->right;}// Driver Codeint main(){ TreeNode* root = new TreeNode(1); root->left = new TreeNode(2); root->right = new TreeNode(3); root->left->left = new TreeNode(4); root->left->right = new TreeNode(5); root->right->right = new TreeNode(6); // Function Call root = shiftRight(root); // Print the inOrder Traversal printTree(root); return 0;} |
2 4 1 5 3 6
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.
