Print K inorder successors of a Binary Tree in O(1) space

• Last Updated : 26 Oct, 2021

Given a Binary Tree and two numbers P and K, the task is to print the K Inorder Successor of the given number P from the Binary tree in constant space.
Examples:

Input: Tree:

1
/   \
12      11
/       /   \
3       4     13
\      /
15    9

P = 12, K = 4
Output: 1 4 15 11
Explanation:
Inorder traversal: 3 12 1 4 15 11 9 13
The 4 Inorder Successor of a node 12 are {1, 4, 15, 11}
Input: Tree:

5
/   \
21    77
/  \      \
61   16    36
\     /
10  3
/
23

P = 23, K = 3
Output: 10 5 77
Explanation:
Inorder traversal: 61 21 16 23 10 5 77 3 36
The 3 Inorder Successor Of a node 23 are {10, 5, 77}.

Approach:
In order to solve this problem, we are using the Morris Inorder Traversal of a Binary Tree to avoid the use of any extra space. Search for the node ‘P’ while generating the inorder sequence. Once found, print the next K nodes that appear in the inorder sequence.
Below is the implementation of the above approach:

C++

 // C++ implementation to print K Inorder// Successor of the Binary Tree// without using extra space  #include using namespace std;  /* A binary tree Node has data,  a pointer to left child   and a pointer to right child */struct tNode {    int data;    struct tNode* left;    struct tNode* right;};  /* Function to traverse the   binary tree without recursion and   without stack */void MorrisTraversal(struct tNode* root,                     int p, int k){    struct tNode *current, *pre;      if (root == NULL)        return;      bool flag = false;      current = root;      while (current != NULL) {          // Check if the left child exists        if (current->left == NULL) {              if (flag == true) {                cout << current->data                     << " ";                k--;            }            if (current->data == p)                flag = true;              // Check if K is 0            if (k == 0)                flag = false;              // Move current to its right            current = current->right;        }        else {              // Find the inorder predecessor            // of current            pre = current->left;            while (pre->right != NULL                   && pre->right != current)                pre = pre->right;              /* Make current as the right               child of its inorder                   predecessor */            if (pre->right == NULL) {                pre->right = current;                current = current->left;            }              /* Revert the changes made in the               'if' part to restore the original                tree i.e., fix the right child                  of predecessor */            else {                pre->right = NULL;                if (flag == true) {                    cout << current->data                         << " ";                    k--;                }                if (current->data == p)                    flag = true;                  if (k == 0)                    flag = false;                  current = current->right;            }        }    }}  /* Function that allocates   a new Node with the    given data and NULL left   and right pointers. */struct tNode* newtNode(int data){    struct tNode* node = new tNode;    node->data = data;    node->left = NULL;    node->right = NULL;      return (node);}  /* Driver code*/int main(){      struct tNode* root = newtNode(1);      root->left = newtNode(12);    root->right = newtNode(11);    root->left->left = newtNode(3);    root->right->left = newtNode(4);    root->right->right = newtNode(13);      root->right->left->right = newtNode(15);    root->right->right->left = newtNode(9);      int p = 12;    int k = 4;      MorrisTraversal(root, p, k);      return 0;}

Java

 // Java implementation to print K Inorder // Successor of the Binary Tree // without using extra space   // A binary tree tNode has data, // a pointer to left child // and a pointer to right child class tNode {     int data;     tNode left, right;       tNode(int item)     {         data = item;         left = right = null;     } }   class BinaryTree{      tNode root;   // Function to traverse a binary tree// without recursion and without stack void MorrisTraversal(tNode root, int p, int k) {     tNode current, pre;       if (root == null)         return;               boolean flag = false;    current = root;           while (current != null)     {         if (current.left == null)        {             if (flag == true)             {                System.out.print(current.data + " ");                 k--;            }            if (current.data == p)            {                flag = true;            }            if (k == 0)             {                flag = false;            }            current = current.right;         }         else         {                          // Find the inorder predecessor            // of current             pre = current.left;             while (pre.right != null &&                    pre.right != current)                 pre = pre.right;               // Make current as right child of            // its inorder predecessor             if (pre.right == null)             {                 pre.right = current;                 current = current.left;             }               // Revert the changes made in the            // 'if' part to restore the original            // tree i.e., fix the right child of            // predecessor            else             {                 pre.right = null;                 if (flag == true)                {                    System.out.print(current.data + " ");                     k--;                }                if (current.data == p)                {                    flag = true;                }                if (k == 0)                 {                    flag = false;                }                current = current.right;             }         }     } }   // Driver codepublic static void main(String args[]) {     BinaryTree tree = new BinaryTree();           tree.root = new tNode(1);     tree.root.left = new tNode(12);     tree.root.right = new tNode(11);     tree.root.left.left = new tNode(3);     tree.root.right.left = new tNode(4);     tree.root.right.right = new tNode(13);           tree.root.right.left.right = new tNode(15);     tree.root.right.right.left = new tNode(9);           int p = 12;    int k = 4;          tree.MorrisTraversal(tree.root, p, k); } }   // This code is contributed by MOHAMMAD MUDASSIR

Python3

 # Python3 implementation to print K Inorder# Successor of the Binary Tree# without using extra space   ''' A binary tree Node has data,  a pointer to left child   and a pointer to right child '''class tNode:          def __init__(self, data):        self.data = data        self.left = None        self.right = None   ''' Function to traverse the   binary tree without recursion and   without stack '''def MorrisTraversal(root, p, k):      current = None    pre = None       if (root == None):        return;       flag = False;       current = root;       while (current != None):           # Check if the left child exists        if (current.left == None):               if (flag == True):                print(current.data, end = ' ')                                  k -= 1                          if (current.data == p):                flag = True;               # Check if K is 0            if (k == 0):                flag = False;               # Move current to its right            current = current.right;                  else:               # Find the inorder predecessor            # of current            pre = current.left                          while (pre.right != None and pre.right != current):                pre = pre.right;               # Make current as the right            #child of its inorder predecessor            if(pre.right == None):                pre.right = current;                current = current.left;                              # Revert the changes made in the            # 'if' part to restore the original             # tree i.e., fix the right child             # of predecessor             else:                pre.right = None;                if (flag == True):                    print(current.data, end = ' ')                                          k -= 1                                  if (current.data == p):                    flag = True;                   if (k == 0):                    flag = False;                   current = current.right;   ''' Function that allocates   a new Node with the    given data and None left   and right pointers. '''def newtNode(data):      node = tNode(data);    return (node);  # Driver codeif __name__=='__main__':       root = newtNode(1);       root.left = newtNode(12);    root.right = newtNode(11);    root.left.left = newtNode(3);    root.right.left = newtNode(4);    root.right.right = newtNode(13);       root.right.left.right = newtNode(15);    root.right.right.left = newtNode(9);       p = 12;    k = 4;       MorrisTraversal(root, p, k);   # This code is contributed by rutvik_56

C#

 // C# program to print inorder traversal // without recursion and stack using System;   // A binary tree tNode has data, // pointer to left child and a // pointer to right child class BinaryTree{      tNode root;   public class tNode {     public int data;     public tNode left, right;       public tNode(int item)     {         data = item;         left = right = null;     } }   // Function to traverse binary tree without // recursion and without stack void MorrisTraversal(tNode root, int p, int k) {     tNode current, pre;       if (root == null)         return;       current = root;     bool flag = false;    while (current != null)     {         if (current.left == null)         {             if (flag == true)             {                Console.Write(current.data + " ");                 k--;            }            if (current.data == p)            {                flag = true;            }            if (k == 0)            {                flag = false;            }            current = current.right;         }         else        {                           // Find the inorder predecessor            // of current             pre = current.left;             while (pre.right != null &&                    pre.right != current)                 pre = pre.right;               // Make current as right child             // of its inorder predecessor             if (pre.right == null)             {                 pre.right = current;                 current = current.left;             }               // Revert the changes made in             // if part to restore the original             // tree i.e., fix the right child             // of predecessor            else            {                 pre.right = null;                 if (flag == true)                 {                    Console.Write(current.data + " ");                     k--;                }                if (current.data == p)                {                    flag = true;                }                if (k == 0)                 {                    flag = false;                }                current = current.right;             }        }     }}   // Driver code public static void Main(String []args) {     BinaryTree tree = new BinaryTree();       tree.root = new tNode(1);     tree.root.left = new tNode(12);     tree.root.right = new tNode(11);     tree.root.left.left = new tNode(3);     tree.root.right.left = new tNode(4);     tree.root.right.right = new tNode(13);           tree.root.right.left.right = new tNode(15);     tree.root.right.right.left = new tNode(9);           int p = 12;    int k = 4;          tree.MorrisTraversal(tree.root, p, k); } }   // This code is contributed by MOHAMMAD MUDASSIR

Javascript


Output:
1 4 15 11

My Personal Notes arrow_drop_up