Reverse Morris traversal using Threaded Binary Tree

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

TBT

Prerequisites :
Morris Traversals
Threaded Binary Trees

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.

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.
   c) Else, if the threaded link between the current node 
      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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP code for reverse Morris Traversal
#include<bits/stdc++.h>
  
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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 
        
        / \ 
    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)

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 
        
        / \ 
    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

chevron_right


Output:

7 3 6 1 5 2 4

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



My Personal Notes arrow_drop_up

A technologist who loves exploring new technologies Passionate and interests in cloud computing and virtualization technologies Also a data nerd and a part time writer who loves writing

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 :


1


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