# Reverse Morris traversal using Threaded Binary Tree

Given a binary tree, task is to do reverse inorder traversal using Morris Traversal. Prerequisites :
Morris Traversals

In a binary tree with n nodes, there are n + 1 NULL pointers which waste memory. So, threaded binary trees makes use of these NULL pointers to save lots of Memory.
So, in Threaded Binary trees these NULL pointers will store some useful information.

1)Storing predecessor information in NULL left pointers only, called as left threaded binary trees.

2)Storing successor information in NULL right pointers only, called as right threaded binary trees.

3)Storing predecessor information in NULL left pointers and successor information in NULL right pointers, called as fully threaded binary trees or simply threaded binary trees.

Morris traversal can be used to do Inorder traversal, reverse Inorder traversal, Pre-order traversal with constant extra memory consumed O(1).

Reverse Morris Traversal : It is simply the reverse form of Morris Traversal.In reverse Morris traversal, first create links to the inorder successor of the current node and print the data using these links, and finally revert the changes to restore original tree, which will give a reverse inorder traversal.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Algorithm :

```1) Initialize Current as root.

2) While current is not NULL :

2.1) If current has no right child
a) Visit the current node.
b) Move to the left child of current.

2.2) Else, here we have 2 cases:
a) Find the inorder successor of current node.
Inorder successor is the left most node
in the right subtree or right child itself.
b) If the left child of the inorder successor is NULL:
1) Set current as the left child of its inorder successor.
2) Move current node to its right.
and it's inorder successor already exists :
1) Set left pointer of the inorder successor as NULL.
2) Visit Current node.
3) Move current to it's left child.
```

## C++

 `// CPP code for reverse Morris Traversal ` `#include ` ` `  `using` `namespace` `std; ` ` `  `// Node structure ` `struct` `Node { ` `    ``int` `data; ` `    ``Node *left, *right; ` `}; ` ` `  `// helper function to create a new node ` `Node *newNode(``int` `data){ ` `    ``Node *temp = ``new` `Node; ` `     `  `    ``temp->data = data; ` `    ``temp->right = temp->left = NULL; ` ` `  `    ``return` `temp; ` `} ` ` `  `// function for reverse inorder traversal ` `void` `MorrisReverseInorder(Node *root) ` `{ ` `     `  `    ``if``(!root)  ` `        ``return` `; ` `     `  `    ``// Auxiliary node pointers ` `    ``Node *curr, *successor; ` `     `  `    ``// initialize current as root ` `    ``curr = root; ` `     `  `    ``while``(curr) ` `    ``{ ` `        ``// case-1, if curr has no right child then  ` `        ``// visit current and move to left child ` `        ``if``(curr -> right == NULL) ` `        ``{ ` `            ``cout << curr->data << ``" "``; ` `            ``curr = curr->left; ` `        ``} ` `         `  `        ``// case-2 ` `        ``else` `        ``{ ` `            ``// find the inorder successor of ` `            ``// current node i.e left most node in  ` `            ``// right subtree or right child itself ` `            ``successor = curr->right; ` `             `  `            ``// finding left most in right subtree ` `            ``while``(successor->left != NULL &&  ` `                  ``successor->left != curr) ` `                    ``successor = successor->left; ` `                 `  `            ``// if the left of inorder successor is NULL ` `            ``if``(successor->left == NULL) ` `            ``{ ` `                ``// then connect left link to current node ` `                ``successor->left = curr; ` `                 `  `                ``// move current to right child ` `                ``curr = curr->right; ` `            ``} ` `             `  `            ``// otherwise inorder successor's left is ` `            ``// not NULL and already left is linked  ` `            ``// with current node ` `            ``else` `            ``{ ` `                ``successor->left = NULL; ` `                 `  `                ``// visiting the current node ` `                ``cout << curr->data << ``" "``; ` ` `  `                ``// move current to its left child  ` `                ``curr = curr->left; ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` ` `  `/* Constructed binary tree is ` `          ``1 ` `        ``/   \ ` `       ``2     3 ` `     ``/  \   /  \ ` `    ``4    5  6    7 ` `*/` ` `  `Node *root = newNode(1); ` `root->left = newNode(2); ` `root->right = newNode(3); ` `root->left->left = newNode(4); ` `root->left->right = newNode(5); ` `root->right->left = newNode(6); ` `root->right->right = newNode(7); ` ` `  `//reverse inorder traversal. ` `MorrisReverseInorder(root); ` ` `  `return` `0; ` `} `

## Java

 `// Java code for reverse Morris Traversal ` `class` `GFG ` `{ ` ` `  `// Node structure ` `static` `class` `Node ` `{ ` `    ``int` `data; ` `    ``Node left, right; ` `}; ` ` `  `// helper function to create a new node ` `static` `Node newNode(``int` `data) ` `{ ` `    ``Node temp = ``new` `Node(); ` `     `  `    ``temp.data = data; ` `    ``temp.right = temp.left = ``null``; ` ` `  `    ``return` `temp; ` `} ` ` `  `// function for reverse inorder traversal ` `static` `void` `MorrisReverseInorder(Node root) ` `{ ` `     `  `    ``if``(root == ``null``)  ` `        ``return` `; ` `     `  `    ``// Auxiliary node pointers ` `    ``Node curr, successor; ` `     `  `    ``// initialize current as root ` `    ``curr = root; ` `     `  `    ``while``(curr != ``null``) ` `    ``{ ` `        ``// case-1, if curr has no right child then  ` `        ``// visit current and move to left child ` `        ``if``(curr . right == ``null``) ` `        ``{ ` `                ``System.out.print( curr.data + ``" "``); ` `            ``curr = curr.left; ` `        ``} ` `         `  `        ``// case-2 ` `        ``else` `        ``{ ` `            ``// find the inorder successor of ` `            ``// current node i.e left most node in  ` `            ``// right subtree or right child itself ` `            ``successor = curr.right; ` `             `  `            ``// finding left most in right subtree ` `            ``while``(successor.left != ``null` `&&  ` `                ``successor.left != curr) ` `                    ``successor = successor.left; ` `                 `  `            ``// if the left of inorder successor is null ` `            ``if``(successor.left == ``null``) ` `            ``{ ` `                ``// then connect left link to current node ` `                ``successor.left = curr; ` `                 `  `                ``// move current to right child ` `                ``curr = curr.right; ` `            ``} ` `             `  `            ``// otherwise inorder successor's left is ` `            ``// not null and already left is linked  ` `            ``// with current node ` `            ``else` `            ``{ ` `                ``successor.left = ``null``; ` `                 `  `                ``// visiting the current node ` `                ``System.out.print( curr.data + ``" "``); ` ` `  `                ``// move current to its left child  ` `                ``curr = curr.left; ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` ` `  `/* Constructed binary tree is ` `        ``1 ` `        ``/ \ ` `    ``2     3 ` `    ``/ \ / \ ` `    ``4 5 6 7 ` `*/` ` `  `Node root = newNode(``1``); ` `root.left = newNode(``2``); ` `root.right = newNode(``3``); ` `root.left.left = newNode(``4``); ` `root.left.right = newNode(``5``); ` `root.right.left = newNode(``6``); ` `root.right.right = newNode(``7``); ` ` `  `// reverse inorder traversal. ` `MorrisReverseInorder(root); ` `} ` `} ` ` `  `// This code is contributed by Arnab Kundu `

## Python3

 `# Python3 for reverse Morris Traversal ` ` `  `# Utility function to create a new  ` `# tree node  ` `class` `newNode: ` `    ``def` `__init__(``self``,data): ` `        ``self``.data ``=` `data ` `        ``self``.left ``=` `self``.right ``=` `None` ` `  `# function for reverse inorder traversal  ` `def` `MorrisReverseInorder(root): ` ` `  `    ``if``( ``not` `root) : ` `        ``return` `         `  `    ``# initialize current as root  ` `    ``curr ``=` `root ` `    ``successor ``=` `0` `     `  `    ``while``(curr):  ` `     `  `        ``# case-1, if curr has no right child then  ` `        ``# visit current and move to left child  ` `        ``if``(curr.right ``=``=` `None``) : ` `         `  `            ``print``(curr.data, end ``=` `" "``)  ` `            ``curr ``=` `curr.left  ` `         `  `        ``# case-2  ` `        ``else``: ` `         `  `            ``# find the inorder successor of  ` `            ``# current node i.e left most node in  ` `            ``# right subtree or right child itself  ` `            ``successor ``=` `curr.right  ` `             `  `            ``# finding left most in right subtree  ` `            ``while``(successor.left !``=` `None` `and` `                  ``successor.left !``=` `curr): ` `                ``successor ``=` `successor.left  ` `                 `  `            ``# if the left of inorder successor is None  ` `            ``if``(successor.left ``=``=` `None``) : ` `             `  `                ``# then connect left link to current node  ` `                ``successor.left ``=` `curr  ` `                 `  `                ``# move current to right child  ` `                ``curr ``=` `curr.right  ` `             `  `            ``# otherwise inorder successor's left is  ` `            ``# not None and already left is linked  ` `            ``# with current node  ` `            ``else``: ` `             `  `                ``successor.left ``=` `None` `                 `  `                ``# visiting the current node  ` `                ``print``(curr.data, end ``=` `" "` `) ` ` `  `                ``# move current to its left child  ` `                ``curr ``=` `curr.left  ` ` `  `# Driver code  ` `if` `__name__ ``=``=``"__main__"``: ` `    ``""" Constructed binary tree is  ` `        ``1  ` `        ``/ \  ` `    ``2     3  ` `    ``/ \ / \  ` `    ``4 5 6 7  ` `"""` ` `  `    ``root ``=` `newNode(``1``)  ` `    ``root.left ``=` `newNode(``2``)  ` `    ``root.right ``=` `newNode(``3``)  ` `    ``root.left.left ``=` `newNode(``4``)  ` `    ``root.left.right ``=` `newNode(``5``)  ` `    ``root.right.left ``=` `newNode(``6``)  ` `    ``root.right.right ``=` `newNode(``7``)  ` ` `  `    ``#reverse inorder traversal.  ` `    ``MorrisReverseInorder(root) ` ` `  `# This code is contributed by ` `# Shubham Singh(SHUBHAMSINGH10) `

## C#

 `// C# code for reverse Morris Traversal  ` `using` `System; ` ` `  `class` `GFG  ` `{  ` ` `  `// Node structure  ` `public` `class` `Node  ` `{  ` `    ``public` `int` `data;  ` `    ``public` `Node left, right;  ` `};  ` ` `  `// helper function to create a new node  ` `static` `Node newNode(``int` `data)  ` `{  ` `    ``Node temp = ``new` `Node();  ` `     `  `    ``temp.data = data;  ` `    ``temp.right = temp.left = ``null``;  ` ` `  `    ``return` `temp;  ` `}  ` ` `  `// function for reverse inorder traversal  ` `static` `void` `MorrisReverseInorder(Node root)  ` `{  ` `     `  `    ``if``(root == ``null``)  ` `        ``return` `;  ` `     `  `    ``// Auxiliary node pointers  ` `    ``Node curr, successor;  ` `     `  `    ``// initialize current as root  ` `    ``curr = root;  ` `     `  `    ``while``(curr != ``null``)  ` `    ``{  ` `        ``// case-1, if curr has no right child then  ` `        ``// visit current and move to left child  ` `        ``if``(curr . right == ``null``)  ` `        ``{  ` `                ``Console.Write( curr.data + ``" "``);  ` `            ``curr = curr.left;  ` `        ``}  ` `         `  `        ``// case-2  ` `        ``else` `        ``{  ` `            ``// find the inorder successor of  ` `            ``// current node i.e left most node in  ` `            ``// right subtree or right child itself  ` `            ``successor = curr.right;  ` `             `  `            ``// finding left most in right subtree  ` `            ``while``(successor.left != ``null` `&&  ` `                ``successor.left != curr)  ` `                    ``successor = successor.left;  ` `                 `  `            ``// if the left of inorder successor is null  ` `            ``if``(successor.left == ``null``)  ` `            ``{  ` `                ``// then connect left link to current node  ` `                ``successor.left = curr;  ` `                 `  `                ``// move current to right child  ` `                ``curr = curr.right;  ` `            ``}  ` `             `  `            ``// otherwise inorder successor's left is  ` `            ``// not null and already left is linked  ` `            ``// with current node  ` `            ``else` `            ``{  ` `                ``successor.left = ``null``;  ` `                 `  `                ``// visiting the current node  ` `                ``Console.Write( curr.data + ``" "``);  ` ` `  `                ``// move current to its left child  ` `                ``curr = curr.left;  ` `            ``}  ` `        ``}  ` `    ``}  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `Main(String []args)  ` `{  ` ` `  `/* Constructed binary tree is  ` `        ``1  ` `        ``/ \  ` `    ``2 3  ` `    ``/ \ / \  ` `    ``4 5 6 7  ` `*/` ` `  `Node root = newNode(1);  ` `root.left = newNode(2);  ` `root.right = newNode(3);  ` `root.left.left = newNode(4);  ` `root.left.right = newNode(5);  ` `root.right.left = newNode(6);  ` `root.right.right = newNode(7);  ` ` `  `// reverse inorder traversal.  ` `MorrisReverseInorder(root);  ` `}  ` `}  ` ` `  `// This code contributed by Rajput-Ji `

Output:

```7 3 6 1 5 2 4
```

Time Complexity : O(n)
Auxiliary Space : O(1)

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 Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

2

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.