Morris Traversal for Inorder in Java

In this section, we will learn about the Morris traversal for inorder in Java. In Morris traversal, we do the traversal of a tree without the help of recursion or stack. The Morris traversal is based on the threaded binary tree. In this traversal, we do the internal modification in order to create the internal links for the inorder successor. Eventually, we revert the modification so that the original tree is restored.

Morris Traversal Inorder Algorithm

The following are the steps involved in the Morris Traversal (Inorder).

Initialize the current node as the root
While the current is not equal to NULL
Whenever the current node does not have the left child
1. Display the data of the current node
2. Visit the right node of the current node, i.e., curr = curr -> right
  Otherwise / Else
  1. Look for the rightmost node in the current left subtree
    OR
    The node whose right child is the current node.
    If the right child == curr node (current node)
    1. Revert the changes. It means the right child should be made as NULL of that
      a node whose right child is the current node
    2. Display the data of the current node
    3. Visit the right node, i.e., curr = curr -> right
      Otherwise / Else
      1. The current node should be made the right child of the rightmost node whichwe found; and
      2. Visit this left child node, i.e., curr = curr -> left

Implementation

Let's see the implementation of the Morris traversal for the inorder using the algorithms described above.

FileName: BTree.java

// a class for representing the 
// nodes of a binary tree
class BTreeNode 
{
int val; // for storing value of the node

// for referring to the left and right nodes
// lt for left and rt for right
BTreeNode lt, rt; 

// constructor of the class BTreeNode
BTreeNode(int item)
{
// initializing the nodes
val = item;
lt = rt = null;
}
}

public class BTree 
{
// the root node
BTreeNode rt;

// Method for traversing a
// binary tree without the help of recursion
// and without the help of stack 
void MorrisTraversalInorder(BTreeNode rt)
{
// curr for the current and pr for the predecessor
BTreeNode curr, pr;

if (rt == null)
{
return;
}

curr = rt;
while (curr != null)
{
if (curr.lt == null)
{
System.out.print(curr.val + " ");
curr = curr.rt;
}
else 
{
// Finding the inorder predecessor of the current node
pr = curr.lt;
while (pr.rt != null && pr.rt != curr)
{
pr = pr.rt;
}
// Making the current as the right child of its
// inorder predecessor
if (pr.rt == null) 
{
pr.rt = curr;
curr = curr.lt;
}

// Reverting the modification made in the
// 'if' block for restoring the original tree
// fixing the right child of the predecessor
else
{
pr.rt = null;
System.out.print(curr.val + " ");
curr = curr.rt;
} 

} 

} 
}
// main method
public static void main(String argvs[])
{
// The binary tree constructed in this code
//                        6
//                      /   \
//	        8	 9
//                  /   \       \
//                1      4      7
//                       /
//                    5

// creating an object of the class BTree
BTree tree = new BTree();

// creating the root node
tree.rt = new BTreeNode(6);

// creating the remaining nodes of the binary tree
tree.rt.lt = new BTreeNode(8);
tree.rt.rt = new BTreeNode(9);
tree.rt.lt.lt = new BTreeNode(1);
tree.rt.lt.rt = new BTreeNode(4);
tree.rt.rt.rt = new BTreeNode(7);
tree.rt.lt.rt.lt = new BTreeNode(5);

// The print statements
System.out.print("The inorder traversal of the binary tree is: \n" );
tree.MorrisTraversalInorder(tree.rt);
}
}

Output:

The inorder traversal of the binary tree is: 
1 8 4 6 9 7

Time Complexity: We observe that every edge of the tree is traversed at most 3 times. The same number of extra edges, as in the input tree, is removed and created. Thus, the total time complexity of the above program is O(n).

Note: At many places, it is said that in recursive approach for doing the inorder traversal does not consume any space. However, this is not true. In recursion, a stack is used, even though we do not provide the stack explicitly.

The Morris traversal can work with the help of the internal modification done in the binary tree. Without internal modification, the Morris traversal cannot work.

Next TopicMorris Traversal for Preorder in Java

← prev next →