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

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 Node 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 Node 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`

Time Complexity: The time complexity of the above code is O(n), as it traverses the whole tree once to print the k inorder successors of the given node. The time complexity is linear because the Morris Traversal algorithm traverses the tree in a single pass.
Auxiliary Space: The Auxiliary Space of the above code is O(1), as it does not use any extra space other than the variables used for traversing the tree.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next