# Preorder, Postorder and Inorder Traversal of a Binary Tree using a single Stack

• Difficulty Level : Hard
• 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 ``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 > 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 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

 `// 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 pre = ``new` `ArrayList<>();` `        ``// Stores inorder traversal``        ``ArrayList in = ``new` `ArrayList<>();` `        ``// Stores postorder traversal``        ``ArrayList post = ``new` `ArrayList<>();` `        ``// Stores the nodes and the order``        ``// in which they are currently visited``        ``Stack 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

 `# 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#

 `// 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> s = ``new` `Stack>();`` ` `        ``// Push root node of the tree``        ``// into the stack``        ``s.Push(``new` `Tuple(root, 1));`` ` `        ``// Traverse the stack while``        ``// the stack is not empty``        ``while` `(s.Count > 0)``        ``{`` ` `            ``// Stores the top``            ``// element of the stack``            ``Tuple 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 temp = s.Peek();``                ``temp = ``new` `Tuple(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(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 temp = s.Peek();``                ``temp = ``new` `Tuple(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(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.`

## Javascript

 ``

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)

My Personal Notes arrow_drop_up