 GFG App
Open App Browser
Continue

# Iterative Postorder Traversal | Set 1 (Using Two Stacks)

We have discussed iterative inorder and iterative preorder traversals. In this post, iterative postorder traversal is discussed, which is more complex than the other two traversals (due to its nature of non-tail recursion, there is an extra statement after the final recursive call to itself). Postorder traversal can easily be done using two stacks, though. The idea is to push reverse postorder traversal to a stack. Once we have the reversed postorder traversal in a stack, we can just pop all items one by one from the stack and print them; this order of printing will be in postorder because of the LIFO property of stacks. Now the question is, how to get reversed postorder elements in a stack – the second stack is used for this purpose. For example, in the following tree, we need to get 1, 3, 7, 6, 2, 5, 4 in a stack. If we take a closer look at this sequence, we can observe that this sequence is very similar to the preorder traversal. The only difference is that the right child is visited before left child, and therefore the sequence is “root right left” instead of “root left right”. So, we can do something like iterative preorder traversal with the following differences:
a) Instead of printing an item, we push it to a stack.
b) We push the left subtree before the right subtree.
Following is the complete algorithm. After step 2, we get the reverse of a postorder traversal in the second stack. We use the first stack to get the correct order.

```1. Push root to first stack.
2. Loop while first stack is not empty
2.1 Pop a node from first stack and push it to second stack
2.2 Push left and right children of the popped node to first stack
3. Print contents of second stack```

Let us consider the following tree Following are the steps to print postorder traversal of the above tree using two stacks.

```1. Push 1 to first stack.
First stack: 1
Second stack: Empty

2. Pop 1 from first stack and push it to second stack.
Push left and right children of 1 to first stack
First stack: 2, 3
Second stack: 1

3. Pop 3 from first stack and push it to second stack.
Push left and right children of 3 to first stack
First stack: 2, 6, 7
Second stack: 1, 3

4. Pop 7 from first stack and push it to second stack.
First stack: 2, 6
Second stack: 1, 3, 7

5. Pop 6 from first stack and push it to second stack.
First stack: 2
Second stack: 1, 3, 7, 6

6. Pop 2 from first stack and push it to second stack.
Push left and right children of 2 to first stack
First stack: 4, 5
Second stack: 1, 3, 7, 6, 2

7. Pop 5 from first stack and push it to second stack.
First stack: 4
Second stack: 1, 3, 7, 6, 2, 5

8. Pop 4 from first stack and push it to second stack.
First stack: Empty
Second stack: 1, 3, 7, 6, 2, 5, 4

The algorithm stops here since there are no more items in the first stack.
Observe that the contents of second stack are in postorder fashion. Print them. ```

Following is the implementation of iterative postorder traversal using two stacks.

## C++

 `#include ` `using` `namespace` `std;`   `// A tree node` `struct` `Node {`   `    ``int` `data;` `    ``Node *left, *right;` `};`   `// Function to create a new node with the given data` `Node* newNode(``int` `data)` `{` `    ``Node* node = ``new` `Node;` `    ``node->data = data;` `    ``node->left = node->right = NULL;` `    ``return` `node;` `}` `// An iterative function to do post order` `// traversal of a given binary tree` `void` `postOrderIterative(Node* root)` `{` `    ``if` `(root == NULL)` `        ``return``;`   `    ``// Create two stacks` `    ``stack s1, s2;`   `    ``// push root to first stack` `    ``s1.push(root);` `    ``Node* node;`   `    ``// Run while first stack is not empty` `    ``while` `(!s1.empty()) {` `        ``// Pop an item from s1 and push it to s2` `        ``node = s1.top();` `        ``s1.pop();` `        ``s2.push(node);`   `        ``// Push left and right children` `        ``// of removed item to s1` `        ``if` `(node->left)` `            ``s1.push(node->left);` `        ``if` `(node->right)` `            ``s1.push(node->right);` `    ``}`   `    ``// Print all elements of second stack` `    ``while` `(!s2.empty()) {` `        ``node = s2.top();` `        ``s2.pop();` `        ``cout << node->data << ``" "``;` `    ``}` `}`   `// Driver code` `int` `main()` `{` `    ``// Let us construct the tree` `    ``// shown in above figure` `    ``Node* root = NULL;` `    ``root = newNode(1);` `    ``root->left = newNode(2);` `    ``root->right = newNode(3);` `    ``root->left->left = newNode(4);` `    ``root->left->right = newNode(5);` `    ``root->right->left = newNode(6);` `    ``root->right->right = newNode(7);`   `    ``postOrderIterative(root);`   `    ``return` `0;` `}`

## C

 `#include ` `#include `   `// Maximum stack size` `#define MAX_SIZE 100`   `// A tree node` `struct` `Node {` `    ``int` `data;` `    ``struct` `Node *left, *right;` `};`   `// Stack type` `struct` `Stack {` `    ``int` `size;` `    ``int` `top;` `    ``struct` `Node** array;` `};`   `// A utility function to create a new tree node` `struct` `Node* newNode(``int` `data)` `{` `    ``struct` `Node* node = (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));` `    ``node->data = data;` `    ``node->left = node->right = NULL;` `    ``return` `node;` `}`   `// A utility function to create a stack of given size` `struct` `Stack* createStack(``int` `size)` `{` `    ``struct` `Stack* stack = (``struct` `Stack*)``malloc``(``sizeof``(``struct` `Stack));` `    ``stack->size = size;` `    ``stack->top = -1;` `    ``stack->array = (``struct` `Node**)``malloc``(stack->size * ``sizeof``(``struct` `Node*));` `    ``return` `stack;` `}`   `// BASIC OPERATIONS OF STACK` `int` `isFull(``struct` `Stack* stack)` `{` `    ``return` `stack->top - 1 == stack->size;` `}`   `int` `isEmpty(``struct` `Stack* stack)` `{` `    ``return` `stack->top == -1;` `}`   `void` `push(``struct` `Stack* stack, ``struct` `Node* node)` `{` `    ``if` `(isFull(stack))` `        ``return``;` `    ``stack->array[++stack->top] = node;` `}`   `struct` `Node* pop(``struct` `Stack* stack)` `{` `    ``if` `(isEmpty(stack))` `        ``return` `NULL;` `    ``return` `stack->array[stack->top--];` `}`   `// An iterative function to do post order traversal of a given binary tree` `void` `postOrderIterative(``struct` `Node* root)` `{` `    ``if` `(root == NULL)` `        ``return``;`   `    ``// Create two stacks` `    ``struct` `Stack* s1 = createStack(MAX_SIZE);` `    ``struct` `Stack* s2 = createStack(MAX_SIZE);`   `    ``// push root to first stack` `    ``push(s1, root);` `    ``struct` `Node* node;`   `    ``// Run while first stack is not empty` `    ``while` `(!isEmpty(s1)) {` `        ``// Pop an item from s1 and push it to s2` `        ``node = pop(s1);` `        ``push(s2, node);`   `        ``// Push left and right children of removed item to s1` `        ``if` `(node->left)` `            ``push(s1, node->left);` `        ``if` `(node->right)` `            ``push(s1, node->right);` `    ``}`   `    ``// Print all elements of second stack` `    ``while` `(!isEmpty(s2)) {` `        ``node = pop(s2);` `        ``printf``(``"%d "``, node->data);` `    ``}` `}`   `// Driver program to test above functions` `int` `main()` `{` `    ``// Let us construct the tree shown in above figure` `    ``struct` `Node* root = NULL;` `    ``root = newNode(1);` `    ``root->left = newNode(2);` `    ``root->right = newNode(3);` `    ``root->left->left = newNode(4);` `    ``root->left->right = newNode(5);` `    ``root->right->left = newNode(6);` `    ``root->right->right = newNode(7);`   `    ``postOrderIterative(root);`   `    ``return` `0;` `}`

## Java

 `// Java program for iterative post` `// order using two stacks`   `import` `java.util.*;` `public` `class` `IterativePostorder {`   `    ``static` `class` `node {` `        ``int` `data;` `        ``node left, right;`   `        ``public` `node(``int` `data)` `        ``{` `            ``this``.data = data;` `        ``}` `    ``}`   `    ``// Two stacks as used in explanation` `    ``static` `Stack s1, s2;`   `    ``static` `void` `postOrderIterative(node root)` `    ``{` `        ``// Create two stacks` `        ``s1 = ``new` `Stack<>();` `        ``s2 = ``new` `Stack<>();`   `        ``if` `(root == ``null``)` `            ``return``;`   `        ``// push root to first stack` `        ``s1.push(root);`   `        ``// Run while first stack is not empty` `        ``while` `(!s1.isEmpty()) {` `            ``// Pop an item from s1 and push it to s2` `            ``node temp = s1.pop();` `            ``s2.push(temp);`   `            ``// Push left and right children of` `            ``// removed item to s1` `            ``if` `(temp.left != ``null``)` `                ``s1.push(temp.left);` `            ``if` `(temp.right != ``null``)` `                ``s1.push(temp.right);` `        ``}`   `        ``// Print all elements of second stack` `        ``while` `(!s2.isEmpty()) {` `            ``node temp = s2.pop();` `            ``System.out.print(temp.data + ``" "``);` `        ``}` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// Let us construct the tree` `        ``// shown in above figure`   `        ``node root = ``null``;` `        ``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``);`   `        ``postOrderIterative(root);` `    ``}` `}`   `// This code is contributed by Rishabh Mahrsee`

## Python3

 `# Python program for iterative postorder ` `# traversal using two stacks`   `# A binary tree node` `class` `Node:` `    `  `    ``# Constructor to create a new node` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# An iterative function to do postorder ` `# traversal of a given binary tree` `def` `postOrderIterative(root): `   `    ``if` `root ``is` `None``:` `        ``return`        `    `  `    ``# Create two stacks ` `    ``s1 ``=` `[]` `    ``s2 ``=` `[]` `    `  `    ``# Push root to first stack` `    ``s1.append(root)` `    `  `    ``# Run while first stack is not empty` `    ``while` `s1:` `        `  `        ``# Pop an item from s1 and ` `        ``# append it to s2` `        ``node ``=` `s1.pop()` `        ``s2.append(node)` `    `  `        ``# Push left and right children of ` `        ``# removed item to s1` `        ``if` `node.left:` `            ``s1.append(node.left)` `        ``if` `node.right:` `            ``s1.append(node.right)`   `        ``# Print all elements of second stack` `    ``while` `s2:` `        ``node ``=` `s2.pop()` `        ``print``(node.data,end``=``" "``)`   `# Driver program to test above function` `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``)` `postOrderIterative(root)`

## C#

 `// C# program for iterative post` `// order using two stacks` `using` `System;` `using` `System.Collections;` `public` `class` `IterativePostorder {`   `    ``public` `class` `node {` `        ``public` `int` `data;` `        ``public` `node left, right;`   `        ``public` `node(``int` `data)` `        ``{` `            ``this``.data = data;` `        ``}` `    ``}`   `    ``// Two stacks as used in explanation` `    ``static` `public` `Stack s1, s2;`   `    ``static` `void` `postOrderIterative(node root)` `    ``{` `        ``// Create two stacks` `        ``s1 = ``new` `Stack();` `        ``s2 = ``new` `Stack();`   `        ``if` `(root == ``null``)` `            ``return``;`   `        ``// Push root to first stack` `        ``s1.Push(root);`   `        ``// Run while first stack is not empty` `        ``while` `(s1.Count > 0) {` `            ``// Pop an item from s1 and Push it to s2` `            ``node temp = (node)s1.Pop();` `            ``s2.Push(temp);`   `            ``// Push left and right children of` `            ``// removed item to s1` `            ``if` `(temp.left != ``null``)` `                ``s1.Push(temp.left);` `            ``if` `(temp.right != ``null``)` `                ``s1.Push(temp.right);` `        ``}`   `        ``// Print all elements of second stack` `        ``while` `(s2.Count > 0) {` `            ``node temp = (node)s2.Pop();` `            ``Console.Write(temp.data + ``" "``);` `        ``}` `    ``}`   `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``// Let us construct the tree` `        ``// shown in above figure`   `        ``node root = ``null``;` `        ``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);`   `        ``postOrderIterative(root);` `    ``}` `}`   `// This code is contributed by Arnab Kundu`

## Javascript

 ``

Output:

`4 5 2 6 7 3 1`

Time complexity: O(n) where n is no of nodes in a binary tree

Auxiliary space: O(n) because using stack s1 and s2

Following is an overview of the above post.
Iterative preorder traversal can be easily implemented using two stacks. The first stack is used to get the reverse postorder traversal. The steps to get a reverse postorder are similar to iterative preorder.
You may also like to see a method which uses only one stack.