Morris Traversal for Preorder in Java

In this section, we will learn about the Morris traversal for preorder 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.

Morris Traversal Preorder Algorithm

The following is the algorithm for the Morris traversal for the preorder, which is almost similar to the Morris traversal for the inorder.

If the left child is null, display the data of the current node, and then move to the right child.
Else, ensure that the right child of the inorder predecessor is pointing to the current node.
Two cases come into the picture:
1. If the current node is being pointed by the right child of the inorder predecessor, then set the right child to NULL, and shift to the right child of the current node.
2. If the right child is NULL, then set it to the current node. Display the data of the current node and then shift to the left child of the current node.
Repeat until and unless the current node is not equal to NULL.

Implementation

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

FileName: BTree1.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 BTree1 
{
// rt is the root node
BTreeNode rt;
// The method morrisTrvrslPreorder() is used for traversing the
// binary tree without the help of recursion
// and without the help of stack 
void morrisTrvrslPreorder(BTreeNode r) 
{
// loop used for traversing
while (r != null) 
{
// If the left child is equal to null, then display
// the data of the current node and move to
// the right child.
if (r.lt == null) 
{
System.out.print(r.val + " ");
r = r.rt;
} 
else 
{
// Finding the inorder predecessor
// curr is the current node
BTreeNode curr = r.lt;
while (curr.rt != null && curr.rt != r) 
{
curr = curr.rt;
}
// When this node is already being pointed out 
// by the right child of the inorder predecessor
if (curr.rt == r) 
{
curr.rt = null;
r = r.rt;
}
// If the right child does not point to the node, then display
// the value of the node and make the right child point towards the node
else 
{
System.out.print(r.val + " ");
curr.rt = r;
r = r.lt;
}
}
}
}
// 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 BTree1
BTree1 tree = new BTree1();
// 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 statement
System.out.print("The inorder traversal of the binary tree is: \n" );
tree.morrisTrvrslPreorder(tree.rt);
}
}

Output:

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

Time Complexity: Since the algorithm is similar to the Morris traversal for the inorder. Therefore, 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 preorder 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. Therefore, if the internal modification is not allowed, one should look after the Morris traversal.

Next TopicPackage Naming Conversion in Java

← prev next →