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

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:

• 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++

// C++ program for the above approach
#include <bits/stdc++.h>
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<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 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<TreeNode> st = new Stack<TreeNode>();
        Queue<TreeNode> 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<TreeNode> temp = new Stack<TreeNode>();

            // 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

<script>

    // JavaScript program for the above approach

    class TreeNode
    {
        constructor(x) {
           this.left = null;
           this.right = null;
           this.val = x;
        }
    }

    // Function to print Inorder
    // Traversal of a Binary Tree
    function printTree(root)
    {
        if (!root)
            return;

        // Traverse left child
        printTree(root.left);

        // Print current node
        document.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
    function shiftRight(root)
    {

        // If tree is empty
        if (root == null)
            return null;

        let st = [];
        let q = [];

        // If right child exists
        if (root.right)
            q.push(root.right);

        root.right = null;

        // If left child exists
        if (root.left != null)
            q.push(root.left);

        root.left = null;

        // Push current node into stack
        st.push(root);

        while (q.length > 0) {

            // Count valid existing nodes
            // in current level
            let n = q.length;
            let temp = [];

            // Iterate existing nodes
            // in the current level
            while (n-- > 0) {

                // If no right child exists
                if (st[st.length - 1].right == null)

                    // Set the rightmost
                    // vacant node
                    st[st.length - 1].right = q[0];

                // If no left child exists
                else {

                    // Set rightmost vacant node
                    st[st.length - 1].left = q[0];

                    // Remove the node as both
                    // child nodes are occupied
                    st.pop();
                }

                // If r̥ight child exist
                if (q[0].right != null)

                    // Push into the queue
                    q.push(q[0].right);

                // Vacate right child
                q[0].right = null;

                // If left child exists
                if (q[0].left != null)

                    // Push into the queue
                    q.push(q[0].left);

                // Vacate left child
                q[0].left = null;

                // Add the node to stack to
                // maintain sequence of nodes
                // present in the level
                temp.push(q[0]);
                q.shift();
            }

            while (st.length > 0)
                st.pop();

            // Add nodes of the next
            // level into the stack st
            while (temp.length > 0) {

                st.push(temp[temp.length - 1]);
                temp.pop();
            }
        }

        // Return the root of the
        // modified Tree
        return root;
    }

    let 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);

</script>

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 <bits/stdc++.h>
#include <iostream>
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<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 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<Integer, List<TreeNode>> 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<Integer, List<TreeNode>> mp = new HashMap<>();
        dfsit(root, 0, mp);

        TreeNode cur = new TreeNode(-1);
        Queue<TreeNode> 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<TreeNode> nd = mp.get(i);
            int j = 0;
            Queue<TreeNode> 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<TreeNode> > mp)
  {
    if (rt == null)
      return;
    if (!mp.ContainsKey(key)) {
      mp.Add(key, new List<TreeNode>());
    }
    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<TreeNode> > mp
      = new Dictionary<int, List<TreeNode> >();
    dfsit(root, 0, mp);

    TreeNode cur = new TreeNode(-1);
    Queue<TreeNode> st = new Queue<TreeNode>();
    st.Enqueue(cur);

    int i = 0;
    int n = mp.Count;
    while (i < n) {
      // Get the list of nodes for the current level
      List<TreeNode> nd = mp[i];
      int j = 0;
      Queue<TreeNode> tmp = new Queue<TreeNode>();
      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<nd.length){
                r.left = nd[j];
                tmp.push(nd[j]);
                j++;
            }
        }
        st = tmp;
        i++;
    }
    return cur.right;
}

// driver code
let 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 Yash Agarwal(yashagarwal2852002)

Output

2 4 1 5 3 6 

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