Preorder, Postorder and Inorder Traversal of a Binary Tree using a single Stack
Last Updated :
18 Jan, 2022
Given a binary tree, the task is to print all the nodes of the binary tree in Pre-order, Post-order, and In-order iteratively using only one stack traversal.
Examples:
Input:
Output:
Preorder Traversal: 1 2 3
Inorder Traversal: 2 1 3
Postorder Traversal: 2 3 1
Input:
Output:
Preorder traversal: 1 2 4 5 3 6 7
Inorder traversal: 4 2 5 1 6 3 7
Post-order traversal: 4 5 2 6 7 3 1
Approach: The problem can be solved using only one stack. The idea is to mark each node of the binary tree by assigning a value, called status code with each node such that value 1 represents that the node is currently visiting in preorder traversal, value 2 represents the nodes is currently visiting in inorder traversal and value 3 represents the node is visiting in the postorder traversal.
- Initialize a stack < pair < Node*, int>> say S.
- Push the root node in the stack with status as 1, i.e {root, 1}.
- Initialize three vectors of integers say preorder, inorder, and postorder.
- Traverse the stack until the stack is empty and check for the following conditions:
- If the status of the top node of the stack is 1 then update the status of the top node of the stack to 2 and push the top node in the vector preorder and insert the left child of the top node if it is not NULL in the stack S.
- If the status of the top node of the stack is 2 then update the status of the top node of the stack to 3 and push the top node in the vector inorder and insert the right child of the top node if it is not NULL in the stack S.
- If the status of the top node of the stack is 3 then push the top node in vector postorder and then pop the top element.
- Finally, print vectors preorder, inorder, and postorder.
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Structure of the
// node of a binary tree
struct Node {
int data;
struct Node *left, *right;
Node(int data)
{
this->data = data;
left = right = NULL;
}
};
// Function to print all nodes of a
// binary tree in Preorder, Postorder
// and Inorder using only one stack
void allTraversal(Node* root)
{
// Stores preorder traversal
vector<int> pre;
// Stores inorder traversal
vector<int> post;
// Stores postorder traversal
vector<int> in;
// Stores the nodes and the order
// in which they are currently visited
stack<pair<Node*, int> > s;
// Push root node of the tree
// into the stack
s.push(make_pair(root, 1));
// Traverse the stack while
// the stack is not empty
while (!s.empty()) {
// Stores the top
// element of the stack
pair<Node*, int> p = s.top();
// If the status of top node
// of the stack is 1
if (p.second == 1) {
// Update the status
// of top node
s.top().second++;
// Insert the current node
// into preorder, pre[]
pre.push_back(p.first->data);
// If left child is not NULL
if (p.first->left) {
// Insert the left subtree
// with status code 1
s.push(make_pair(
p.first->left, 1));
}
}
// If the status of top node
// of the stack is 2
else if (p.second == 2) {
// Update the status
// of top node
s.top().second++;
// Insert the current node
// in inorder, in[]
in.push_back(p.first->data);
// If right child is not NULL
if (p.first->right) {
// Insert the right subtree into
// the stack with status code 1
s.push(make_pair(
p.first->right, 1));
}
}
// If the status of top node
// of the stack is 3
else {
// Push the current node
// in post[]
post.push_back(p.first->data);
// Pop the top node
s.pop();
}
}
cout << "Preorder Traversal: ";
for (int i = 0; i < pre.size(); i++) {
cout << pre[i] << " ";
}
cout << "\n";
// Printing Inorder
cout << "Inorder Traversal: ";
for (int i = 0; i < in.size(); i++) {
cout << in[i] << " ";
}
cout << "\n";
// Printing Postorder
cout << "Postorder Traversal: ";
for (int i = 0; i < post.size(); i++) {
cout << post[i] << " ";
}
cout << "\n";
}
// Driver Code
int main()
{
// Creating the root
struct Node* root = new Node(1);
root->left = new Node(2);
root->right = new Node(3);
root->left->left = new Node(4);
root->left->right = new Node(5);
root->right->left = new Node(6);
root->right->right = new Node(7);
// Function call
allTraversal(root);
return 0;
}
// Java program for the above approach
import java.util.ArrayList;
import java.util.Stack;
class GFG
{
static class Pair
{
Node first;
int second;
public Pair(Node first, int second)
{
this.first = first;
this.second = second;
}
}
// Structure of the
// node of a binary tree
static class Node
{
int data;
Node left, right;
Node(int data)
{
this.data = data;
left = right = null;
}
};
// Function to print all nodes of a
// binary tree in Preorder, Postorder
// and Inorder using only one stack
static void allTraversal(Node root)
{
// Stores preorder traversal
ArrayList<Integer> pre = new ArrayList<>();
// Stores inorder traversal
ArrayList<Integer> in = new ArrayList<>();
// Stores postorder traversal
ArrayList<Integer> post = new ArrayList<>();
// Stores the nodes and the order
// in which they are currently visited
Stack<Pair> s = new Stack<>();
// Push root node of the tree
// into the stack
s.push(new Pair(root, 1));
// Traverse the stack while
// the stack is not empty
while (!s.empty())
{
// Stores the top
// element of the stack
Pair p = s.peek();
// If the status of top node
// of the stack is 1
if (p.second == 1)
{
// Update the status
// of top node
s.peek().second++;
// Insert the current node
// into preorder, pre[]
pre.add(p.first.data);
// If left child is not null
if (p.first.left != null)
{
// Insert the left subtree
// with status code 1
s.push(new Pair(p.first.left, 1));
}
}
// If the status of top node
// of the stack is 2
else if (p.second == 2) {
// Update the status
// of top node
s.peek().second++;
// Insert the current node
// in inorder, in[]
in.add(p.first.data);
// If right child is not null
if (p.first.right != null) {
// Insert the right subtree into
// the stack with status code 1
s.push(new Pair(p.first.right, 1));
}
}
// If the status of top node
// of the stack is 3
else {
// Push the current node
// in post[]
post.add(p.first.data);
// Pop the top node
s.pop();
}
}
System.out.print("Preorder Traversal: ");
for (int i : pre) {
System.out.print(i + " ");
}
System.out.println();
// Printing Inorder
System.out.print("Inorder Traversal: ");
for (int i : in) {
System.out.print(i + " ");
}
System.out.println();
// Printing Postorder
System.out.print("Postorder Traversal: ");
for (int i : post) {
System.out.print(i + " ");
}
System.out.println();
}
// Driver Code
public static void main(String[] args) {
// Creating the root
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);
// Function call
allTraversal(root);
}
}
// This code is contributed by sanjeev255
# Python3 program for the above approach
# Structure of the
# node of a binary tree
class Node:
def __init__(self, x):
self.data = x
self.left = None
self.right = None
# Function to print all nodes of a
# binary tree in Preorder, Postorder
# and Inorder using only one stack
def allTraversal(root):
# Stores preorder traversal
pre = []
# Stores inorder traversal
post = []
# Stores postorder traversal
inn = []
# Stores the nodes and the order
# in which they are currently visited
s = []
# Push root node of the tree
# into the stack
s.append([root, 1])
# Traverse the stack while
# the stack is not empty
while (len(s) > 0):
# Stores the top
# element of the stack
p = s[-1]
#del s[-1]
# If the status of top node
# of the stack is 1
if (p[1] == 1):
# Update the status
# of top node
s[-1][1] += 1
# Insert the current node
# into preorder, pre[]
pre.append(p[0].data)
# If left child is not NULL
if (p[0].left):
# Insert the left subtree
# with status code 1
s.append([p[0].left, 1])
# If the status of top node
# of the stack is 2
elif (p[1] == 2):
# Update the status
# of top node
s[-1][1] += 1
# Insert the current node
# in inorder, in[]
inn.append(p[0].data);
# If right child is not NULL
if (p[0].right):
# Insert the right subtree into
# the stack with status code 1
s.append([p[0].right, 1])
# If the status of top node
# of the stack is 3
else:
# Push the current node
# in post[]
post.append(p[0].data);
# Pop the top node
del s[-1]
print("Preorder Traversal: ",end=" ")
for i in pre:
print(i,end=" ")
print()
# Printing Inorder
print("Inorder Traversal: ",end=" ")
for i in inn:
print(i,end=" ")
print()
# Printing Postorder
print("Postorder Traversal: ",end=" ")
for i in post:
print(i,end=" ")
print()
# Driver Code
if __name__ == '__main__':
# Creating the root
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
root.right.left = Node(6)
root.right.right = Node(7)
# Function call
allTraversal(root)
# This code is contributed by mohit kumar 29.
// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG {
// Class containing left and
// right child of current
// node and key value
class Node {
public int data;
public Node left, right;
public Node(int x)
{
data = x;
left = right = null;
}
}
// Function to print all nodes of a
// binary tree in Preorder, Postorder
// and Inorder using only one stack
static void allTraversal(Node root)
{
// Stores preorder traversal
List<int> pre = new List<int>();
// Stores inorder traversal
List<int> In = new List<int>();
// Stores postorder traversal
List<int> post = new List<int>();
// Stores the nodes and the order
// in which they are currently visited
Stack<Tuple<Node, int>> s = new Stack<Tuple<Node, int>>();
// Push root node of the tree
// into the stack
s.Push(new Tuple<Node, int>(root, 1));
// Traverse the stack while
// the stack is not empty
while (s.Count > 0)
{
// Stores the top
// element of the stack
Tuple<Node, int> p = s.Peek();
// If the status of top node
// of the stack is 1
if (p.Item2 == 1)
{
// Update the status
// of top node
Tuple<Node, int> temp = s.Peek();
temp = new Tuple<Node, int>(temp.Item1, temp.Item2 + 1);
s.Pop();
s.Push(temp);
// Insert the current node
// into preorder, pre[]
pre.Add(p.Item1.data);
// If left child is not null
if (p.Item1.left != null)
{
// Insert the left subtree
// with status code 1
s.Push(new Tuple<Node, int>(p.Item1.left, 1));
}
}
// If the status of top node
// of the stack is 2
else if (p.Item2 == 2) {
// Update the status
// of top node
Tuple<Node, int> temp = s.Peek();
temp = new Tuple<Node, int>(temp.Item1, temp.Item2 + 1);
s.Pop();
s.Push(temp);
// Insert the current node
// in inorder, in[]
In.Add(p.Item1.data);
// If right child is not null
if (p.Item1.right != null) {
// Insert the right subtree into
// the stack with status code 1
s.Push(new Tuple<Node, int>(p.Item1.right, 1));
}
}
// If the status of top node
// of the stack is 3
else {
// Push the current node
// in post[]
post.Add(p.Item1.data);
// Pop the top node
s.Pop();
}
}
Console.Write("Preorder Traversal: ");
foreach(int i in pre) {
Console.Write(i + " ");
}
Console.WriteLine();
// Printing Inorder
Console.Write("Inorder Traversal: ");
foreach(int i in In) {
Console.Write(i + " ");
}
Console.WriteLine();
// Printing Postorder
Console.Write("Postorder Traversal: ");
foreach(int i in post) {
Console.Write(i + " ");
}
Console.WriteLine();
}
static void Main() {
// Creating the root
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);
// Function call
allTraversal(root);
}
}
// This code is contributed by suresh07.
<script>
// Javascript program for the above approach
class Pair
{
constructor(first, second)
{
this.first = first;
this.second = second;
}
}
// Structure of the
// node of a binary tree
class Node
{
constructor(data)
{
this.data = data;
this.left = this.right = null;
}
}
// Function to print all nodes of a
// binary tree in Preorder, Postorder
// and Inorder using only one stack
function allTraversal(root)
{
// Stores preorder traversal
let pre = [];
// Stores inorder traversal
let In = [];
// Stores postorder traversal
let post = [];
// Stores the nodes and the order
// in which they are currently visited
let s = [];
// Push root node of the tree
// into the stack
s.push(new Pair(root, 1));
// Traverse the stack while
// the stack is not empty
while (s.length != 0)
{
// Stores the top
// element of the stack
let p = s[s.length - 1];
// If the status of top node
// of the stack is 1
if (p.second == 1)
{
// Update the status
// of top node
s[s.length - 1].second++;
// Insert the current node
// into preorder, pre[]
pre.push(p.first.data);
// If left child is not null
if (p.first.left != null)
{
// Insert the left subtree
// with status code 1
s.push(new Pair(p.first.left, 1));
}
}
// If the status of top node
// of the stack is 2
else if (p.second == 2)
{
// Update the status
// of top node
s[s.length - 1].second++;
// Insert the current node
// in inorder, in[]
In.push(p.first.data);
// If right child is not null
if (p.first.right != null)
{
// Insert the right subtree into
// the stack with status code 1
s.push(new Pair(p.first.right, 1));
}
}
// If the status of top node
// of the stack is 3
else
{
// Push the current node
// in post[]
post.push(p.first.data);
// Pop the top node
s.pop();
}
}
document.write("Preorder Traversal: ");
for(let i = 0; i < pre.length; i++)
{
document.write(pre[i] + " ");
}
document.write("<br>");
// Printing Inorder
document.write("Inorder Traversal: ");
for(let i = 0; i < In.length; i++)
{
document.write(In[i] + " ");
}
document.write("<br>");
// Printing Postorder
document.write("Postorder Traversal: ");
for(let i = 0; i < post.length; i++)
{
document.write(post[i] + " ");
}
document.write("<br>");
}
// Driver Code
// Creating the root
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);
// Function call
allTraversal(root);
// This code is contributed by unknown2108
</script>
Output: Preorder Traversal: 1 2 4 5 3 6 7
Inorder Traversal: 4 2 5 1 6 3 7
Postorder Traversal: 4 5 2 6 7 3 1
Time Complexity: O(N)
Auxiliary Space: O(N)
Similar Reads
Postorder traversal of Binary Tree without recursion and without stack Given a binary tree, perform postorder traversal. Prerequisite - Inorder/preorder/postorder traversal of tree We have discussed the below methods for postorder traversal. 1) Recursive Postorder Traversal. 2) Postorder traversal using Stack. 2) Postorder traversal using two Stacks. Approach 1 The app
15 min read
Pre Order, Post Order and In Order traversal of a Binary Tree in one traversal | (Using recursion) Given a binary tree, the task is to print all the nodes of the binary tree in Pre-order, Post-order, and In-order in one iteration. Examples: Input: Output: Pre Order: 1 2 4 5 3 6 7 Post Order: 4 5 2 6 7 3 1 In Order: 4 2 5 1 6 3 7 Input: Output: Pre Order: 1 2 4 8 12 5 9 3 6 7 10 11 Post Order: 12
9 min read
Check if given Preorder, Inorder and Postorder traversals are of same tree Given Preorder, Inorder, and Postorder traversals of some tree. Write a program to check if they all are of the same tree. Examples: Input: Inorder -> 4 2 5 1 3 Preorder -> 1 2 4 5 3 Postorder -> 4 5 2 3 1Output: YesExplanation: All of the above three traversals are of the same tree 1 / \ 2
15+ min read
Binary Search Tree (BST) Traversals – Inorder, Preorder, Post Order Given a Binary Search Tree, The task is to print the elements in inorder, preorder, and postorder traversal of the Binary Search Tree. Input: A Binary Search TreeOutput: Inorder Traversal: 10 20 30 100 150 200 300Preorder Traversal: 100 20 10 30 200 150 300Postorder Traversal: 10 30 20 150 300 200 1
10 min read
Post Order Traversal of Binary Tree in O(N) using O(1) space 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 9Output: 8 9 4 5 2 6 7 3 1Input: 5 / \ 7 3 / \ / \ 4 1
15+ min read