Related Articles
Print K inorder successors of a Binary Tree in O(1) space
• Last Updated : 04 Dec, 2020

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 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 predecssor``            ``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`
Output:
`1 4 15 11`

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.

My Personal Notes arrow_drop_up