Prerequisites:- Morris Inorder Traversal, Tree Traversals (Inorder, Preorder and Postorder)
Given a Binary Tree, the task is to print the elements in post order using O(N) time complexity and constant space.
Input: 1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
Output: 4 8 9 5 2 6 7 3 1
Input: 5
/ \
7 3
/ \ / \
4 11 13 9
/ \
8 4
Output: 4 8 4 11 7 13 9 3 5
Method 1: Using Morris Inorder Traversal
Below is the diagram showing the right most child in left subtree, pointing to it’s inorder successor.
Below is the diagram which highlights the path 1->2->5->9 and the way the nodes are processed and printed as per the above algorithm.
Below is the implementation of the above approach:
filter_none
edit
play_arrow
brightness_4
// Java program to implement
// Post Order traversal
// of Binary Tree in O(N)
// time and O(1) space
// Definition of the
// binary tree
**class**
TreeNode {
**public**
**int**
data;
**public**
TreeNode left;
**public**
TreeNode right;
**public**
TreeNode(``**int**
data)
{
**this**``.data = data;
}
**public**
String toString()
{
**return**
data +
" "``;
}
}
**public**
**class**
PostOrder {
TreeNode root;
// Function to find Post Order
// Traversal Using Constant space
**void**
postOrderConstantspace(TreeNode
root)
{
**if**
(root ==
**null**``)
**return**``;
TreeNode current
=
**new**
TreeNode(-``1``),
pre =
**null**``;
TreeNode prev =
**null**``,
succ =
**null**``,
temp =
**null**``;
current.left = root;
**while**
(current !=
**null**``) {
// Go to the right child
// if current does not
// have a left child
**if**
(current.left ==
**null**``) {
current = current.right;
}
**else**
{
// Traverse left child
pre = current.left;
// Find the right most child
// in the left subtree
**while**
(pre.right !=
**null**
&& pre.right != current)
pre = pre.right;
**if**
(pre.right ==
**null**``) {
// Make current as the right
// child of the right most node
pre.right = current;
// Traverse the left child
current = current.left;
}
**else**
{
pre.right =
**null**``;
succ = current;
current = current.left;
prev =
**null**``;
// Traverse along the right
// subtree to the
// right-most child
**while**
(current !=
**null**``) {
temp = current.right;
current.right = prev;
prev = current;
current = temp;
}
// Traverse back from
// right most child to
// current's left child node
**while**
(prev !=
**null**``) {
System.out.print(prev);
temp = prev.right;
prev.right = current;
current = prev;
prev = temp;
}
current = succ;
current = current.right;
}
}
}
}
// Driver Code
**public**
**static**
**void**
main(String[] args)
{
/* Constructed tree is as follows:-
1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
*/
PostOrder tree =
**new**
PostOrder();
tree.root =
**new**
TreeNode(``1``);
tree.root.left =
**new**
TreeNode(``2``);
tree.root.right =
**new**
TreeNode(``3``);
tree.root.left.left =
**new**
TreeNode(``4``);
tree.root.left.right
=
**new**
TreeNode(``5``);
tree.root.right.left
=
**new**
TreeNode(``6``);
tree.root.right.right
=
**new**
TreeNode(``7``);
tree.root.left.right.left
=
**new**
TreeNode(``8``);
tree.root.left.right.right
=
**new**
TreeNode(``9``);
tree.postOrderConstantspace(
tree.root);
}
}
Output:
4 8 9 5 2 6 7 3 1
_Time Complexity: _O(N)
Auxiliary Space:_ O(1)_
Method 2: In method 1, we traverse a path, reverse references, print nodes as we restore the references by reversing them again. In method 2, instead of reversing paths and restoring the structure, we traverse to parent node from the current node using the current node’s left subtree. This could be faster depending on the tree structure, for example in a right-skewed tree.
The following algorithm and diagrams provide the details of the approach.
#data structures #recursion #tree #inorder traversal #interview-preparation #morris-traversal #postorder traversal