We have seen different ways of performing postorder traversal on Binary Trees.
- Post Order Traversal.
- Iterative Postorder Traversal using Two Stacks.
- Iterative Postorder Traversal using One Stack.
Here is another way of performing the postorder traversal on a Binary Tree iteratively using a single stack.
Consider the Below Terminologies:
0 - Left element 1 - Right element 2 - Node element
Following is the detailed algorithm:
Take a Stack and perform the below operations: 1) Insert a pair of the root node as (node, 0). 2) Pop the top element to get the pair (Let a = node and b be the variable) If b is equal to 0: Push another pair as (node, 1) and Push the left child as (node->left, 0) Repeat Step 2 Else If b is equal to 1: Push another pair as (node, 2) and Push right child of node as (node->right, 0) Repeat Step 2 Else If b is equal to 2: Print(node->data) 3) Repeat the above steps while stack is not empty
Consider the Below Binary Tree with just 3 nodes:
Illustration:
1) Push(a, 0) Stack - (a, 0) 2) top = (a, 0) Push(a, 1) Push(b, 0) Stack - (b, 0) (a, 1) 3) top = (b, 0) Push(b, 1) Stack - (b, 1) (a, 1) 4) top = (b, 1) Push(b, 2) Stack - (b, 2) (a, 1) 5) top = (b, 2) print(b) Stack -(a, 1) 6) top = (a, 1) push(a, 2) push(c, 0) Stack - (c, 0) (a, 2) 7) top = (c, 0) push(c, 1) Stack - (c, 1) (a, 2) 8) top = (c, 1) push(c, 2) Stack - (c, 2) (a, 2) 9) top = (c, 2) print(c) Stack - (a, 2) 10) top = (a, 2) print(a) Stack - empty()
Below is the implementation of the above approach:
C++
// C++ program to print postorder traversal // iteratively #include <bits/stdc++.h> using namespace std;
// Binary Tree Node struct Node {
int data;
struct Node* left;
struct Node* right;
}; // Helper function to create a // new Binary Tree node struct Node* newNode( int data)
{ struct Node* node = new Node;
node->data = data;
node->left = NULL;
node->right = NULL;
return (node);
} // Function to perform postorder // traversal iteratively void iterativePostorder(Node* root)
{ stack<pair<Node*, int > > st;
st.push(make_pair(root, 0));
while (!st.empty()) {
struct Node* temp = st.top().first;
int b = st.top().second;
st.pop();
if (temp == NULL)
continue ;
if (b == 0) {
st.push(make_pair(temp, 1));
if (temp->left != NULL)
st.push(make_pair(temp->left, 0));
}
else if (b == 1) {
st.push(make_pair(temp, 2));
if (temp->right != NULL)
st.push(make_pair(temp->right, 0));
}
else
cout << temp->data << " " ;
}
} // Driver Code int main()
{ // Construct the below Binary Tree
// 1
// / \
// 2 3
// / \
// 4 5
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
iterativePostorder(root);
return 0;
} |
Java
// Java program to print postorder traversal // iteratively import java.util.*;
class GFG
{ //pair class static class Pair
{ Node first;
int second;
Pair(Node a, int b)
{
first = a;
second = b;
}
} // Binary Tree Node static class Node
{ int data;
Node left;
Node right;
}; // Helper function to create a // new Binary Tree node static Node newNode( int data)
{ Node node = new Node();
node.data = data;
node.left = null ;
node.right = null ;
return (node);
} // Function to perform postorder // traversal iteratively static void iterativePostorder(Node root)
{ Stack<Pair> st = new Stack<Pair>();
st.add( new Pair(root, 0 ));
while (st.size() > 0 )
{
Node temp = st.peek().first;
int b = st.peek().second;
st.pop();
if (temp == null )
continue ;
if (b == 0 )
{
st.add( new Pair(temp, 1 ));
if (temp.left != null )
st.add( new Pair(temp.left, 0 ));
}
else if (b == 1 )
{
st.add( new Pair(temp, 2 ));
if (temp.right != null )
st.add( new Pair(temp.right, 0 ));
}
else
System.out.print( temp.data + " " );
}
} // Driver Code public static void main(String args[])
{ // Construct the below Binary Tree
// 1
// / \
// 2 3
// / \
// 4 5
Node root = newNode( 1 );
root.left = newNode( 2 );
root.right = newNode( 3 );
root.left.left = newNode( 4 );
root.left.right = newNode( 5 );
iterativePostorder(root);
} } // This code is contributed by Arnab Kundu |
Python3
# Python program to print postorder traversal # iteratively # pair class class Pair:
def __init__( self , a, b):
self .first = a
self .second = b
# Binary Tree Node class Node :
def __init__( self ):
self .data = 0
self .left = None
self .right = None
# Helper function to create a # new Binary Tree node def newNode(data):
node = Node()
node.data = data
node.left = None
node.right = None
return (node)
# Function to perform postorder # traversal iteratively def iterativePostorder( root):
st = []
st.append(Pair(root, 0 ))
while ( len (st)> 0 ):
temp = st[ - 1 ].first
b = st[ - 1 ].second
st.pop()
if (temp = = None ):
continue
if (b = = 0 ) :
st.append(Pair(temp, 1 ))
if (temp.left ! = None ):
st.append(Pair(temp.left, 0 ))
elif (b = = 1 ):
st.append(Pair(temp, 2 ))
if (temp.right ! = None ):
st.append(Pair(temp.right, 0 ))
else :
print ( temp.data ,end = " " )
# Driver Code # Construct the below Binary Tree # 1 # / \ # 2 3 # / \ # 4 5 root = newNode( 1 )
root.left = newNode( 2 )
root.right = newNode( 3 )
root.left.left = newNode( 4 )
root.left.right = newNode( 5 )
iterativePostorder(root) # This code is contributed by Arnab Kundu |
C#
// C# program to print postorder traversal // iteratively using System;
using System.Collections.Generic;
class GFG
{ //pair class public class Pair
{ public Node first;
public int second;
public Pair(Node a, int b)
{
first = a;
second = b;
}
} // Binary Tree Node public class Node
{ public int data;
public Node left;
public Node right;
}; // Helper function to create a // new Binary Tree node static Node newNode( int data)
{ Node node = new Node();
node.data = data;
node.left = null ;
node.right = null ;
return (node);
} // Function to perform postorder // traversal iteratively static void iterativePostorder(Node root)
{ Stack<Pair> st = new Stack<Pair>();
st.Push( new Pair(root, 0));
while (st.Count > 0)
{
Node temp = st.Peek().first;
int b = st.Peek().second;
st.Pop();
if (temp == null )
continue ;
if (b == 0)
{
st.Push( new Pair(temp, 1));
if (temp.left != null )
st.Push( new Pair(temp.left, 0));
}
else if (b == 1)
{
st.Push( new Pair(temp, 2));
if (temp.right != null )
st.Push( new Pair(temp.right, 0));
}
else
Console.Write(temp.data + " " );
}
} // Driver Code public static void Main(String []args)
{ // Construct the below Binary Tree
// 1
// / \
// 2 3
// / \
// 4 5
Node root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
iterativePostorder(root);
} } // This code is contributed by 29AjayKumar |
Javascript
<script> // JavaScript program to print
// postorder traversal iteratively
// Binary Tree Node
class Node
{
constructor(data) {
this .left = null ;
this .right = null ;
this .data = data;
}
}
// Helper function to create a
// new Binary Tree node
function newNode(data)
{
let node = new Node(data);
return (node);
}
// Function to perform postorder
// traversal iteratively
function iterativePostorder(root)
{
let st = [];
st.push([root, 0]);
while (st.length > 0)
{
let temp = st[st.length - 1][0];
let b = st[st.length - 1][1];
st.pop();
if (temp == null )
continue ;
if (b == 0)
{
st.push([temp, 1]);
if (temp.left != null )
st.push([temp.left, 0]);
}
else if (b == 1)
{
st.push([temp, 2]);
if (temp.right != null )
st.push([temp.right, 0]);
}
else
document.write(temp.data + " " );
}
}
// Construct the below Binary Tree
// 1
// / \
// 2 3
// / \
// 4 5
let root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
iterativePostorder(root);
</script> |
Output:
4 5 2 3 1
Time Complexity: O(N)
Auxiliary Space: O(N)