Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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 <bits/stdc++.h>
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 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 

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 code
if __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




<script>
    // Javascript 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
    {
        constructor(item) {
           this.left = null;
           this.right = null;
           this.data = item;
        }
    }
      
    let root;
   
    // Function to traverse a binary tree
    // without recursion and without stack
    function MorrisTraversal(root, p, k)
    {
        let current, pre;
  
        if (root == null)
            return;
  
        let flag = false;
        current = root;
  
        while (current != null)
        {
            if (current.left == null)
            {
                if (flag == true)
                {
                    document.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 the
                // 'if' part to restore the original
                // tree i.e., fix the right child of
                // predecessor
                else
                {
                    pre.right = null;
                    if (flag == true)
                    {
                        document.write(current.data + " ");
                        k--;
                    }
                    if (current.data == p)
                    {
                        flag = true;
                    }
                    if (k == 0)
                    {
                        flag = false;
                    }
                    current = current.right;
                }
            }
        }
    }
      
    root = new tNode(1);
    root.left = new tNode(12);
    root.right = new tNode(11);
    root.left.left = new tNode(3);
    root.right.left = new tNode(4);
    root.right.right = new tNode(13);
       
    root.right.left.right = new tNode(15);
    root.right.right.left = new tNode(9);
       
    let p = 12;
    let k = 4;
       
    MorrisTraversal(root, p, k);
  
// This code is contributed by decode2207.
</script>
Output: 
1 4 15 11

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!