# Modify a Binary Tree by shifting all nodes to as far right as possible

Last Updated : 01 Mar, 2023

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    6

Input: 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:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Structure of a Tree node` `struct` `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 Tree` `void` `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 possible` `TreeNode* shiftRight(TreeNode* root)` `{`   `    ``// If tree is empty` `    ``if` `(!root)` `        ``return` `NULL;`   `    ``stack st;` `    ``queue 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 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 Code` `int` `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;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;` `public` `class` `Main` `{` `  `  `    ``// Class containing left and` `    ``// right child of current` `    ``// node and key value` `    ``static` `class` `TreeNode {` `        `  `        ``public` `int` `val;` `        ``public` `TreeNode left, right;` `        `  `        ``public` `TreeNode(``int` `x)` `        ``{` `            ``val = x;` `            ``left = right = ``null``;` `        ``}` `    ``}` `    `  `    ``// Function to print Inorder` `    ``// Traversal of a Binary Tree` `    ``static` `void` `printTree(TreeNode root)` `    ``{` `        ``if` `(root == ``null``)` `            ``return``;` `  `  `        ``// Traverse left child` `        ``printTree(root.left);` `  `  `        ``// Print current node` `        ``System.out.print(root.val + ``" "``);` `  `  `        ``// Traverse right child` `        ``printTree(root.right);` `    ``}` `  `  `    ``// Function to shift all nodes of the` `    ``// given Binary Tree to as far as` `    ``// right possible` `    ``static` `TreeNode shiftRight(TreeNode root)` `    ``{` `  `  `        ``// If tree is empty` `        ``if` `(root == ``null``)` `            ``return` `null``;` `  `  `        ``Stack st = ``new` `Stack();` `        ``Queue q = ``new` `LinkedList<>();` `  `  `        ``// If right child exists` `        ``if` `(root.right != ``null``)` `            ``q.add(root.right);` `  `  `        ``root.right = ``null``;` `  `  `        ``// If left child exists` `        ``if` `(root.left != ``null``)` `            ``q.add(root.left);` `  `  `        ``root.left = ``null``;` `  `  `        ``// Push current node into stack` `        ``st.push(root);` `  `  `        ``while` `(q.size() > ``0``) {` `  `  `            ``// Count valid existing nodes` `            ``// in current level` `            ``int` `n = q.size();` `            ``Stack temp = ``new` `Stack();` `  `  `            ``// Iterate existing nodes` `            ``// in the current level` `            ``while` `(n-- > ``0``) {` `  `  `                ``// If no right child exists` `                ``if` `(((TreeNode)st.peek()).right == ``null``)` `  `  `                    ``// Set the rightmost` `                    ``// vacant node` `                    ``((TreeNode)st.peek()).right = (TreeNode)q.peek();` `  `  `                ``// If no left child exists` `                ``else` `{` `  `  `                    ``// Set rightmost vacant node` `                    ``((TreeNode)st.peek()).left = (TreeNode)q.peek();` `  `  `                    ``// Remove the node as both` `                    ``// child nodes are occupied` `                    ``st.pop();` `                ``}` `  `  `                ``// If r?ight child exist` `                ``if` `(((TreeNode)q.peek()).right != ``null``)` `  `  `                    ``// Push into the queue` `                    ``q.add(((TreeNode)q.peek()).right);` `  `  `                ``// Vacate right child` `                ``((TreeNode)q.peek()).right = ``null``;` `  `  `                ``// If left child exists` `                ``if` `(((TreeNode)q.peek()).left != ``null``)` `  `  `                    ``// Push into the queue` `                    ``q.add(((TreeNode)q.peek()).left);` `  `  `                ``// Vacate left child` `                ``((TreeNode)q.peek()).left = ``null``;` `  `  `                ``// Add the node to stack to` `                ``// maintain sequence of nodes` `                ``// present in the level` `                ``temp.push(((TreeNode)q.peek()));` `                ``q.remove();` `            ``}` `  `  `            ``while` `(st.size() > ``0``)` `                ``st.pop();` `  `  `            ``// Add nodes of the next` `            ``// level into the stack st` `            ``while` `(temp.size() > ``0``) {` `  `  `                ``st.push(temp.peek());` `                ``temp.pop();` `            ``}` `        ``}` `  `  `        ``// Return the root of the` `        ``// modified Tree` `        ``return` `root;` `    ``}` `    `  `    ``public` `static` `void` `main(String[] args) {` `        ``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);` `    ``}` `}`   `// This code is contributed by suresh07.`

## Python3

 `# Python 3 program for the above approach`   `# Structure of a Tree node` `class` `TreeNode:`   `    ``def` `__init__(``self``,val):` `        ``self``.val ``=` `val` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# Function to print Inorder` `# Traversal of a Binary Tree` `def` `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 possible` `def` `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 Code` `if` `__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.`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections;` `class` `GFG {` `    `  `    ``// Class containing left and` `    ``// right child of current` `    ``// node and key value` `    ``class` `TreeNode {` `       `  `        ``public` `int` `val;` `        ``public` `TreeNode left, right;` `       `  `        ``public` `TreeNode(``int` `x)` `        ``{` `            ``val = x;` `            ``left = right = ``null``;` `        ``}` `    ``}` `    `  `    ``// Function to print Inorder` `    ``// Traversal of a Binary Tree` `    ``static` `void` `printTree(TreeNode root)` `    ``{` `        ``if` `(root == ``null``)` `            ``return``;` ` `  `        ``// Traverse left child` `        ``printTree(root.left);` ` `  `        ``// Print current node` `        ``Console.Write(root.val + ``" "``);` ` `  `        ``// Traverse right child` `        ``printTree(root.right);` `    ``}` ` `  `    ``// Function to shift all nodes of the` `    ``// given Binary Tree to as far as` `    ``// right possible` `    ``static` `TreeNode shiftRight(TreeNode root)` `    ``{` ` `  `        ``// If tree is empty` `        ``if` `(root == ``null``)` `            ``return` `null``;` ` `  `        ``Stack st = ``new` `Stack();` `        ``Queue q = ``new` `Queue();` ` `  `        ``// If right child exists` `        ``if` `(root.right != ``null``)` `            ``q.Enqueue(root.right);` ` `  `        ``root.right = ``null``;` ` `  `        ``// If left child exists` `        ``if` `(root.left != ``null``)` `            ``q.Enqueue(root.left);` ` `  `        ``root.left = ``null``;` ` `  `        ``// Push current node into stack` `        ``st.Push(root);` ` `  `        ``while` `(q.Count > 0) {` ` `  `            ``// Count valid existing nodes` `            ``// in current level` `            ``int` `n = q.Count;` `            ``Stack temp = ``new` `Stack();` ` `  `            ``// Iterate existing nodes` `            ``// in the current level` `            ``while` `(n-- > 0) {` ` `  `                ``// If no right child exists` `                ``if` `(((TreeNode)st.Peek()).right == ``null``)` ` `  `                    ``// Set the rightmost` `                    ``// vacant node` `                    ``((TreeNode)st.Peek()).right = (TreeNode)q.Peek();` ` `  `                ``// If no left child exists` `                ``else` `{` ` `  `                    ``// Set rightmost vacant node` `                    ``((TreeNode)st.Peek()).left = (TreeNode)q.Peek();` ` `  `                    ``// Remove the node as both` `                    ``// child nodes are occupied` `                    ``st.Pop();` `                ``}` ` `  `                ``// If r?ight child exist` `                ``if` `(((TreeNode)q.Peek()).right != ``null``)` ` `  `                    ``// Push into the queue` `                    ``q.Enqueue(((TreeNode)q.Peek()).right);` ` `  `                ``// Vacate right child` `                ``((TreeNode)q.Peek()).right = ``null``;` ` `  `                ``// If left child exists` `                ``if` `(((TreeNode)q.Peek()).left != ``null``)` ` `  `                    ``// Push into the queue` `                    ``q.Enqueue(((TreeNode)q.Peek()).left);` ` `  `                ``// Vacate left child` `                ``((TreeNode)q.Peek()).left = ``null``;` ` `  `                ``// Add the node to stack to` `                ``// maintain sequence of nodes` `                ``// present in the level` `                ``temp.Push(((TreeNode)q.Peek()));` `                ``q.Dequeue();` `            ``}` ` `  `            ``while` `(st.Count > 0)` `                ``st.Pop();` ` `  `            ``// Add nodes of the next` `            ``// level into the stack st` `            ``while` `(temp.Count > 0) {` ` `  `                ``st.Push(temp.Peek());` `                ``temp.Pop();` `            ``}` `        ``}` ` `  `        ``// Return the root of the` `        ``// modified Tree` `        ``return` `root;` `    ``}` `    `  `  ``static` `void` `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);` `  ``}` `}`   `// This code is contributed by decode2207.`

## Javascript

 ``

Output

`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 ` `#include ` `using` `namespace` `std;`   `// Structure of a Tree node` `struct` `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 Tree` `void` `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 >& 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 > mp;` `    ``int` `i = 0;`   `    ``dfsit(root, 0, mp);` `    ``int` `n = mp.size();` `    ``TreeNode* cur = ``new` `TreeNode(-1);` `  `  ` `  `    ``queue st;` `    ``st.push(cur);`   `  ``while` `(i < n) {` `        ``vector nd = mp[i];` `        ``int` `j = 0;` `        ``queue 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 Code` `int` `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;` `}`

## Java

 `import` `java.util.*;`   `// Definition of TreeNode class` `class` `TreeNode {` `    ``int` `val;` `    ``TreeNode left;` `    ``TreeNode right;` `    ``// Constructor for TreeNode` `    ``TreeNode(``int` `x) {` `        ``val = x;` `        ``left = right = ``null``;` `    ``}` `}`   `class` `GFG {` `      ``// Function to print the in-order traversal of a binary tree` `    ``public` `void` `printTree(TreeNode root) {` `        ``if` `(root == ``null``) ``return``;` `        `  `        ``// Recursively print the left subtree` `        ``printTree(root.left);` `      `  `        ``System.out.print(root.val + ``" "``);` `      `  `          ``// Recursively print the right subtree` `        ``printTree(root.right);` `    ``}` `    `  `      ``// Recursive function to store the nodes in a map with level as key` `    ``public` `void` `dfsit(TreeNode rt, ``int` `key, Map> mp) {` `        ``if` `(rt == ``null``) ``return``;` `        ``if` `(!mp.containsKey(key)) {` `            ``mp.put(key, ``new` `ArrayList<>());` `        ``}` `        ``mp.get(key).add(rt);` `        ``dfsit(rt.right, key + ``1``, mp);` `        ``dfsit(rt.left, key + ``1``, mp);` `        ``rt.left = ``null``;` `        ``rt.right = ``null``;` `    ``}`   `    ``public` `TreeNode shiftRight(TreeNode root) {` `        ``Map> mp = ``new` `HashMap<>();` `        ``dfsit(root, ``0``, mp);`   `        ``TreeNode cur = ``new` `TreeNode(-``1``);` `        ``Queue st = ``new` `LinkedList<>();` `        ``st.offer(cur);`   `        ``int` `i = ``0``;` `        ``int` `n = mp.size();` `        ``while` `(i < n) {` `               ``// Get the list of nodes for the current level` `            ``List nd = mp.get(i);` `            ``int` `j = ``0``;` `            ``Queue tmp = ``new` `LinkedList<>();` `            ``while` `(j < nd.size()) {` `                ``TreeNode r = st.poll();` `                  ``// Set the right child of the node to the current node in the list` `                ``r.right = nd.get(j);` `                ``tmp.offer(nd.get(j));` `                ``j++;` `                ``if` `(j < nd.size()) {` `                    ``r.left = nd.get(j);` `                    ``tmp.offer(nd.get(j));` `                    ``j++;` `                ``}` `            ``}` `            ``st = tmp;` `            ``i++;` `        ``}` `        ``return` `cur.right;` `    ``}` `    `  `      ``//Driver Code` `    ``public` `static` `void` `main(String[] args) {` `        ``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``);`   `        ``GFG solution = ``new` `GFG();` `        ``root = solution.shiftRight(root);`   `        ``solution.printTree(root);` `    ``}` `}`

## Python3

 `# Python 3 program for the above approach` `from` `typing ``import` `List` `from` `collections ``import` `deque`   `# Structure of a Tree node` `class` `TreeNode:` `    ``def` `__init__(``self``, x: ``int``) ``-``> ``None``:` `        ``self``.val ``=` `x` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# Function to print Inorder Traversal of a Binary Tree` `def` `print_tree(root: TreeNode) ``-``> ``None``:` `    ``if` `not` `root:` `        ``return` `    ``# Traverse left child` `    ``print_tree(root.left)` `    ``# Print current node` `    ``print``(root.val, end``=``" "``)` `    ``# Traverse right child` `    ``print_tree(root.right)`   `def` `dfsit(rt: TreeNode, key: ``int``, mp: ``List``[``List``[TreeNode]]) ``-``> ``None``:` `    ``if` `not` `rt:` `        ``return` `    ``mp[key].append(rt)` `    ``dfsit(rt.right, key ``+` `1``, mp)` `    ``dfsit(rt.left, key ``+` `1``, mp)` `    ``rt.left ``=` `None` `    ``rt.right ``=` `None`   `def` `shift_right(root: TreeNode) ``-``> TreeNode:` `    ``tmp ``=` `root` `    ``mp ``=` `[[] ``for` `_ ``in` `range``(``10000``)]` `    ``i ``=` `0` `    ``dfsit(root, ``0``, mp)` `    ``n ``=` `len``([lst ``for` `lst ``in` `mp ``if` `lst])` `    ``cur ``=` `TreeNode(``-``1``)` `    ``st ``=` `deque([cur])` `    ``while` `i < n:` `        ``nd ``=` `mp[i]` `        ``j ``=` `0` `        ``tmp ``=` `deque()` `        ``while` `j < ``len``(nd):` `            ``r ``=` `st.popleft()` `            ``r.right ``=` `nd[j]` `            ``tmp.append(nd[j])` `            ``j ``+``=` `1` `            ``if` `j < ``len``(nd):` `                ``r.left ``=` `nd[j]` `                ``tmp.append(nd[j])` `                ``j ``+``=` `1` `        ``st ``=` `tmp` `        ``i ``+``=` `1` `    ``return` `cur.right`   `# Driver Code` `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 ``=` `shift_right(root)`   `# Print the inOrder Traversal` `print_tree(root)`   `# This code is contributed by Potta Lokesh`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `// Definition of TreeNode class` `public` `class` `TreeNode {` `  ``public` `int` `val;` `  ``public` `TreeNode left;` `  ``public` `TreeNode right;` `  `  `  ``// Constructor for TreeNode` `  ``public` `TreeNode(``int` `x)` `  ``{` `    ``val = x;` `    ``left = right = ``null``;` `  ``}` `}`   `class` `GFG {` `  `  `  ``// Function to print the in-order traversal of a binary` `  ``// tree` `  ``public` `void` `PrintTree(TreeNode root)` `  ``{` `    ``if` `(root == ``null``)` `      ``return``;`   `    ``// Recursively print the left subtree` `    ``PrintTree(root.left);`   `    ``Console.Write(root.val + ``" "``);`   `    ``// Recursively print the right subtree` `    ``PrintTree(root.right);` `  ``}`   `  ``// Recursive function to store the nodes in a map with` `  ``// level as key` `  ``public` `void` `dfsit(TreeNode rt, ``int` `key,` `                    ``Dictionary<``int``, List > mp)` `  ``{` `    ``if` `(rt == ``null``)` `      ``return``;` `    ``if` `(!mp.ContainsKey(key)) {` `      ``mp.Add(key, ``new` `List());` `    ``}` `    ``mp[key].Add(rt);` `    ``dfsit(rt.right, key + 1, mp);` `    ``dfsit(rt.left, key + 1, mp);` `    ``rt.left = ``null``;` `    ``rt.right = ``null``;` `  ``}`   `  ``public` `TreeNode ShiftRight(TreeNode root)` `  ``{` `    ``Dictionary<``int``, List > mp` `      ``= ``new` `Dictionary<``int``, List >();` `    ``dfsit(root, 0, mp);`   `    ``TreeNode cur = ``new` `TreeNode(-1);` `    ``Queue st = ``new` `Queue();` `    ``st.Enqueue(cur);`   `    ``int` `i = 0;` `    ``int` `n = mp.Count;` `    ``while` `(i < n) {` `      ``// Get the list of nodes for the current level` `      ``List nd = mp[i];` `      ``int` `j = 0;` `      ``Queue tmp = ``new` `Queue();` `      ``while` `(j < nd.Count) {` `        ``TreeNode r = st.Dequeue();` `        ``// Set the right child of the node to the` `        ``// current node in the list` `        ``r.right = nd[j];` `        ``tmp.Enqueue(nd[j]);` `        ``j++;` `        ``if` `(j < nd.Count) {` `          ``r.left = nd[j];` `          ``tmp.Enqueue(nd[j]);` `          ``j++;` `        ``}` `      ``}` `      ``st = tmp;` `      ``i++;` `    ``}` `    ``return` `cur.right;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `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);`   `    ``GFG solution = ``new` `GFG();` `    ``root = solution.ShiftRight(root);`   `    ``solution.PrintTree(root);` `  ``}` `}`

## Javascript

 `// Javascript program for the above approach` `// structure of a tree node` `class TreeNode{` `    ``constructor(x){` `        ``this``.val = x;` `        ``this``.left = ``null``;` `        ``this``.right = ``null``;` `    ``}` `}`   `// function to print norder ` `// traversal of a binary tree` `function` `printTree(root){` `    ``if``(root == ``null``) ` `        ``return``;` `    ``// traverse left child` `    ``printTree(root.left);` `    `  `    ``// print current node` `    ``console.log(root.val + ``" "``);` `    `  `    ``// traverse the right child` `    ``printTree(root.right);` `}`   `function` `dfsit(rt, key, mp){` `    ``if``(rt == ``null``) ``return``;` `    ``if``(mp.has(key)){` `        ``mp.get(key).push(rt);` `    ``}``else``{` `        ``mp.set(key, [rt]);` `    ``}` `    ``dfsit(rt.right, key+1, mp);` `    ``dfsit(rt.left, key+1, mp);` `    ``rt.left = ``null``;` `    ``rt.right = ``null``;` `}`   `function` `shiftRight(root){` `    ``let tmp = root;` `    ``let mp = ``new` `Map();` `    ``let i = 0;` `    `  `    ``dfsit(root, 0, mp);` `    ``let n = mp.size;` `    ``let cur = ``new` `TreeNode(-1);` `    `  `    ``let st = [];` `    ``st.push(cur);` `    `  `    ``while``(i < n){` `        ``let nd = mp.get(i);` `        ``let j = 0;` `        ``let tmp = [];` `        ``while``(j < nd.length){` `            ``let r = st.shift();` `            ``r.right = nd[j];` `            ``tmp.push(nd[j]);` `            ``j++;` `            ``if``(j

Output

`2 4 1 5 3 6 `

Time Complexity: O(NlogN)
Auxiliary Space: O(N)

Previous
Next