Iterative Postorder Traversal | Set 2 (Using One Stack)
Last Updated :
24 Apr, 2025
Postorder traversal is a depth-first tree traversal method where each node is processed after its left and right children. While recursive postorder traversal is common, an iterative approach using a single stack offers a more efficient alternative. This article explains how to implement iterative postorder traversal, eliminating recursion while maintaining the correct node visit order, and improving both space and time efficiency.
Refer Iterative Postorder Traversal | Set 1 (Using Two Stacks) for recursive approach
Examples:
Input:
1
/ \
2 3
/ \
4 5
Output: 4 5 2 3 1
Explanation: Postorder traversal (Left->Right->Root) of the tree is 4 5 2 3 1.
Input:
8
/ \
1 5
\ / \
7 10 6
\ /
10 6
Output: 10 7 1 6 10 6 5 8
Explanation: Postorder traversal (Left->Right->Root) of the tree is 10 7 1 6 10 6 5 8.
[Expected Approach 1] Pushing the Root Twice - O(n) Time and O(n) Space
In this iterative version, we push each node onto the stack twice: the first push marks the node, and the second one indicates we need to process it after its children. We keep moving to the left child until we reach the leaf nodes, then start processing nodes by popping them from the stack. While popping if we find stack top() is same as root then go for root->right else print root.
C++
#include <iostream>
#include <vector>
#include <stack>
using namespace std;
struct Node {
int data;
Node *left, *right;
Node(int x) {
data = x;
left = nullptr;
right = nullptr;
}
};
vector<int> postOrder(Node* root) {
vector<int> res;
stack<Node*> st;
while (true) {
while (root) {
st.push(root);
st.push(root);
root = root->left;
}
if (st.empty())
return res;
root = st.top();
st.pop();
if (!st.empty() && st.top() == root)
root = root->right;
else {
res.push_back(root->data);
root = nullptr;
}
}
return res;
}
int main() {
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);
vector<int> postOrderList = postOrder(root);
for (auto it : postOrderList)
cout << it << " ";
return 0;
}
import java.util.*;
class Node {
int data;
Node left, right;
Node(int x) {
data = x;
left = null;
right = null;
}
}
public class Main {
static List<Integer> postOrder(Node root) {
List<Integer> res = new ArrayList<>();
Stack<Node> st = new Stack<>();
while (true) {
while (root != null) {
st.push(root);
st.push(root);
root = root.left;
}
if (st.isEmpty())
return res;
root = st.pop();
if (!st.isEmpty() && st.peek() == root)
root = root.right;
else {
res.add(root.data);
root = null;
}
}
}
public static void main(String[] args) {
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);
List<Integer> postOrderList = postOrder(root);
for (int it : postOrderList)
System.out.print(it + " ");
}
}
# Python implementation
class Node:
def __init__(self, x):
self.data = x
self.left = None
self.right = None
def postOrder(root):
res = []
st = []
while True:
while root:
st.append(root)
st.append(root)
root = root.left
if not st:
return res
root = st.pop()
if st and st[-1] == root:
root = root.right
else:
res.append(root.data)
root = None
if __name__ == '__main__':
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
postOrderList = postOrder(root)
print(' '.join(map(str, postOrderList)))
// C# implementation
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node left, right;
public Node(int x) {
data = x;
left = null;
right = null;
}
}
class GfG {
static List<int> PostOrder(Node root) {
List<int> res = new List<int>();
Stack<Node> st = new Stack<Node>();
while (true) {
while (root != null) {
st.Push(root);
st.Push(root);
root = root.left;
}
if (st.Count == 0)
return res;
root = st.Pop();
if (st.Count > 0 && st.Peek() == root)
root = root.right;
else {
res.Add(root.data);
root = null;
}
}
}
static void Main() {
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);
List<int> postOrderList = PostOrder(root);
Console.WriteLine(string.Join(" ", postOrderList));
}
}
// JavaScript implementation
class Node {
constructor(x) {
this.data = x;
this.left = null;
this.right = null;
}
}
function postOrder(root) {
const res = [];
const st = [];
while (true) {
while (root) {
st.push(root);
st.push(root);
root = root.left;
}
if (st.length === 0)
return res;
root = st.pop();
if (st.length > 0 && st[st.length - 1] === root)
root = root.right;
else {
res.push(root.data);
root = null;
}
}
}
const 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);
const postOrderList = postOrder(root);
console.log(postOrderList.join(' '));
[Expected Approach 2] Moving both Root and Right - O(n) Time and O(n) Space
The idea is to move down to leftmost node using left pointer. While moving down, push root and root's right child to stack. Once we reach leftmost node, print it if it doesn't have a right child. If it has a right child, then change root so that the right child is processed before.
Following is detailed algorithm.
1.1 Create an empty stack
2.1 Do following while root is not NULL
a) Push root's right child and then root to stack.
b) Set root as root's left child.
2.2 Pop an item from stack and set it as root.
a) If the popped item has a right child and the right child
is at top of stack, then remove the right child from stack,
push the root back and set root as root's right child.
b) Else print root's data and set root as NULL.
2.3 Repeat steps 2.1 and 2.2 while stack is not empty.
C++
// C++ program for iterative postorder
// traversal using one stack
#include <bits/stdc++.h>
using namespace std;
class Node {
public:
int data;
Node* left;
Node* right;
Node(int x) {
data = x;
left = right = nullptr;
}
};
// Function for iterative post-order
// traversal using one stack
vector<int> postOrder(Node* root) {
vector<int> result;
if (root == nullptr) {
return result;
}
stack<Node*> stk;
// Step 2.1: Process until root becomes null
while (root != nullptr || !stk.empty()) {
// Move to the leftmost node and push
// right child and root
while (root != nullptr) {
if (root->right != nullptr) {
stk.push(root->right);
}
stk.push(root);
root = root->left;
}
// Step 2.2: Pop an item from the stack
root = stk.top();
stk.pop();
// Step 2.2a: If the popped node has a right child
// and the right child is on the top of the stack
if (!stk.empty() && root->right != nullptr
&& stk.top() == root->right) {
stk.pop();
stk.push(root);
root = root->right;
}
else {
// Step 2.2b: Else, print the node's
// data and set root as null
result.push_back(root->data);
root = nullptr;
}
}
return result;
}
void printArray(const vector<int>& arr) {
for (int data : arr) {
cout << data << " ";
}
cout << endl;
}
int main() {
// Representation of input binary tree:
// 1
// / \
// 2 3
// / \
// 4 5
Node* root = new Node(1);
root->left = new Node(2);
root->right = new Node(3);
root->right->left = new Node(4);
root->right->right = new Node(5);
vector<int> result = postOrder(root);
printArray(result);
return 0;
}
// C program for iterative postorder
// traversal using one stack
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* left;
struct Node* right;
};
// Function for iterative post-order
// traversal using one stack
int* postOrder(struct Node* root, int* size) {
*size = 0;
if (root == NULL) return NULL;
struct Node* stk[100];
int result[100];
int top = -1, resIndex = 0;
// Step 2.1: Process until root becomes null
while (root != NULL || top >= 0) {
// Move to the leftmost node and push
// right child and root
while (root != NULL) {
if (root->right != NULL) {
stk[++top] = root->right;
}
stk[++top] = root;
root = root->left;
}
// Step 2.2: Pop an item from the stack
root = stk[top--];
// Step 2.2a: If the popped node has a right child
// and the right child is on the top of the stack
if (top >= 0 && root->right != NULL
&& stk[top] == root->right) {
top--;
stk[++top] = root;
root = root->right;
}
else {
// Step 2.2b: Else, add the node's data
result[resIndex++] = root->data;
root = NULL;
}
}
int* output = (int*)malloc(resIndex * sizeof(int));
for (int i = 0; i < resIndex; i++) {
output[i] = result[i];
}
*size = resIndex;
return output;
}
void printArray(int* arr, int size) {
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
struct Node* createNode(int x) {
struct Node* newNode
= (struct Node*)malloc(sizeof(struct Node));
newNode->data = x;
newNode->left = newNode->right = NULL;
return newNode;
}
int main() {
// Representation of input binary tree:
// 1
// / \
// 2 3
// / \
// 4 5
struct Node* root = createNode(1);
root->left = createNode(2);
root->right = createNode(3);
root->right->left = createNode(4);
root->right->right = createNode(5);
int size;
int* result = postOrder(root, &size);
printArray(result, size);
return 0;
}
// Java program for iterative postorder
// traversal using one stack
import java.util.ArrayList;
import java.util.Stack;
class Node {
int data;
Node left, right;
Node(int x) {
data = x;
left = right = null;
}
}
public class GfG {
// Function for iterative post-order
// traversal using one stack
static ArrayList<Integer> postOrder(Node root) {
ArrayList<Integer> result = new ArrayList<>();
if (root == null) {
return result;
}
Stack<Node> stk = new Stack<>();
// Step 2.1: Process until root becomes null
while (root != null || !stk.isEmpty()) {
// Move to the leftmost node and push
// right child and root
while (root != null) {
if (root.right != null) {
stk.push(root.right);
}
stk.push(root);
root = root.left;
}
// Step 2.2: Pop an item from the stack
root = stk.pop();
// Step 2.2a: If the popped node has a right child
// and the right child is on the top of the stack
if (!stk.isEmpty() && root.right != null
&& stk.peek() == root.right) {
stk.pop();
stk.push(root);
root = root.right;
}
else {
// Step 2.2b: Else, print the node's
// data and set root as null
result.add(root.data);
root = null;
}
}
return result;
}
static void printArray(ArrayList<Integer> arr) {
for (int data : arr) {
System.out.print(data + " ");
}
System.out.println();
}
public static void main(String[] args) {
// Representation of input binary tree:
// 1
// / \
// 2 3
// / \
// 4 5
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.right.left = new Node(4);
root.right.right = new Node(5);
ArrayList<Integer> result = postOrder(root);
printArray(result);
}
}
# Python program for iterative postorder
# traversal using one stack
class Node:
def __init__(self, x):
self.data = x
self.left = None
self.right = None
# Function for iterative post-order traversal
# using one stack
def postOrder(root):
result = []
if root is None:
return result
stk = []
# Step 2.1: Process until root becomes null
while root is not None or len(stk) > 0:
# Move to the leftmost node and push
# right child and root
while root is not None:
if root.right is not None:
stk.append(root.right)
stk.append(root)
root = root.left
# Step 2.2: Pop an item from the stack
root = stk.pop()
# Step 2.2a: If the popped node has a right child
# and the right child is on the top of the stack
if len(stk) > 0 and root.right is not None and stk[-1] == root.right:
stk.pop()
stk.append(root)
root = root.right
else:
# Step 2.2b: Else, add the node's
# data and set root as null
result.append(root.data)
root = None
return result
def printArray(arr):
print(" ".join(map(str, arr)))
if __name__ == "__main__":
# Representation of input binary tree:
# 1
# / \
# 2 3
# / \
# 4 5
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.right.left = Node(4)
root.right.right = Node(5)
result = postOrder(root)
printArray(result)
// C# program for iterative postorder
// traversal using one stack
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node left, right;
public Node(int x) {
data = x;
left = right = null;
}
}
class GfG {
// Function for iterative post-order
// traversal using one stack
static List<int> postOrder(Node root) {
List<int> result = new List<int>();
if (root == null) {
return result;
}
Stack<Node> stk = new Stack<Node>();
// Step 2.1: Process until root becomes null
while (root != null || stk.Count > 0) {
// Move to the leftmost node and push
// right child and root
while (root != null) {
if (root.right != null) {
stk.Push(root.right);
}
stk.Push(root);
root = root.left;
}
// Step 2.2: Pop an item from the stack
root = stk.Pop();
// Step 2.2a: If the popped node has a right child
// and the right child is on the top of the stack
if (stk.Count > 0 && root.right != null
&& stk.Peek() == root.right) {
stk.Pop();
stk.Push(root);
root = root.right;
} else {
// Step 2.2b: Else, add the node's
// data and set root as null
result.Add(root.data);
root = null;
}
}
return result;
}
static void printArray(List<int> arr) {
foreach (int data in arr) {
Console.Write(data + " ");
}
Console.WriteLine();
}
public static void Main(string[] args) {
// Representation of input binary tree:
// 1
// / \
// 2 3
// / \
// 4 5
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.right.left = new Node(4);
root.right.right = new Node(5);
List<int> result = postOrder(root);
printArray(result);
}
}
// JavaScript program for iterative postorder
// traversal using one stack
class Node {
constructor(x) {
this.data = x;
this.left = null;
this.right = null;
}
}
// Function for iterative post-order
// traversal using one stack
function postOrder(root) {
const result = [];
if (root === null) {
return result;
}
const stk = [];
// Step 2.1: Process until root becomes null
while (root !== null || stk.length > 0) {
// Move to the leftmost node and push
// right child and root
while (root !== null) {
if (root.right !== null) {
stk.push(root.right);
}
stk.push(root);
root = root.left;
}
// Step 2.2: Pop an item from the stack
root = stk.pop();
// Step 2.2a: If the popped node has a right child
// and the right child is on the top of the stack
if (stk.length > 0 && root.right !== null
&& stk[stk.length - 1] === root.right) {
stk.pop();
stk.push(root);
root = root.right;
}
else {
// Step 2.2b: Else, add the node's
// data and set root as null
result.push(root.data);
root = null;
}
}
return result;
}
function printArray(arr) {
console.log(arr.join(" "));
}
// Representation of input binary tree:
// 1
// / \
// 2 3
// / \
// 4 5
const root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.right.left = new Node(4);
root.right.right = new Node(5);
const result = postOrder(root);
printArray(result);
Let us consider the following tree
Following are the steps to print postorder traversal of the above tree using one stack.
1. Right child of 1 exists. Push 3 to stack. Push 1 to stack. Move to left child.
Stack: 3, 1
2. Right child of 2 exists. Push 5 to stack. Push 2 to stack. Move to left child.
Stack: 3, 1, 5, 2
3. Right child of 4 doesn't exist. Push 4 to stack. Move to left child.
Stack: 3, 1, 5, 2, 4
4. Current node is NULL. Pop 4 from stack. Right child of 4 doesn't exist. Print 4. Set current node to NULL.
Stack: 3, 1, 5, 2
5. Current node is NULL. Pop 2 from stack. Since right child of 2 equals stack top element, pop 5 from stack. Now push 2 to stack. Move current node to right child of 2 i.e. 5
Stack: 3, 1, 2
6. Right child of 5 doesn't exist. Push 5 to stack. Move to left child.
Stack: 3, 1, 2, 5
7. Current node is NULL. Pop 5 from stack. Right child of 5 doesn't exist. Print 5. Set current node to NULL.
Stack: 3, 1, 2
8. Current node is NULL. Pop 2 from stack. Right child of 2 is not equal to stack top element. Print 2. Set current node to NULL.
Stack: 3, 1
9. Current node is NULL. Pop 1 from stack. Since right child of 1 equals stack top element, pop 3 from stack. Now push 1 to stack. Move current node to right child of 1 i.e. 3
Stack: 1
10. Repeat the same as above steps and Print 6, 7 and 3.
Pop 1 and Print 1.
Time Complexity: O(n), where n is the number of nodes, as each node is visited once during traversal.
Auxiliary Space: O(h), where h is the height of the tree, due to the stack, with h being O(n) in the worst case for a skewed tree.
[Expected Approach 3] Tracking Last Visited Node - O(n) Time and O(n) Space
The traversal order in postorder is left child, right child, and then the node itself. Instead of recursion, the algorithm simulates the recursive calls using a stack. It first pushes nodes onto the stack as it moves down the left side of the tree. Once it reaches a leaf, it starts processing the nodes by checking if the right child has been visited. If not, it traverses the right subtree; otherwise, it processes the node and adds it to the result.
C++
#include <iostream>
#include <vector>
#include <stack>
#include <queue>
#include <sstream>
using namespace std;
struct Node {
int data;
Node* left;
Node* right;
Node(int val) {
data = val;
left = nullptr;
right = nullptr;
}
};
vector<int> postOrder(Node* root) {
vector<int> res;
if (!root) return res;
stack<Node*> s;
Node* lastVisited = nullptr;
while (!s.empty() || root) {
// Keep moving to the left
// until we reach a null
if (root) {
s.push(root);
root = root->left;
}
else {
// Take out an item from stack
Node* peekNode = s.top();
// If the taken out item has a
// right child and the right child
// is not visited, move to the right
if (peekNode->right && lastVisited != peekNode->right) {
root = peekNode->right;
// If there is no right child
// or the right child is already
// visited, then add peekNode to the
// result and remove from the stack
} else {
res.push_back(peekNode->data);
lastVisited = s.top();
s.pop();
}
}
}
return res;
}
// Driver program to test above functions
int main() {
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);
printf("Post order traversal of binary tree is:\n[");
vector<int> res = postOrder(root);
for (auto it : res)
cout << it << " ";
printf("]");
return 0;
}
import java.util.*;
class Node {
int data;
Node left, right;
Node(int val) {
data = val;
left = right = null;
}
}
public class Main {
static List<Integer> postOrder(Node root) {
List<Integer> res = new ArrayList<>();
if (root == null) return res;
Stack<Node> s = new Stack<>();
Node lastVisited = null;
while (!s.isEmpty() || root != null) {
if (root != null) {
s.push(root);
root = root.left;
} else {
Node peekNode = s.peek();
if (peekNode.right != null && lastVisited != peekNode.right) {
root = peekNode.right;
} else {
res.add(peekNode.data);
lastVisited = s.pop();
}
}
}
return res;
}
public static void main(String[] args) {
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);
System.out.println("Post order traversal of binary tree is:");
List<Integer> res = postOrder(root);
System.out.print("[");
for (int i = 0; i < res.size(); i++) {
System.out.print(res.get(i) + (i < res.size() - 1 ? " " : ""));
}
System.out.println("]");
}
}
class Node:
def __init__(self, val):
self.data = val
self.left = None
self.right = None
def postOrder(root):
res = []
if root is None:
return res
s = []
lastVisited = None
while s or root:
if root:
s.append(root)
root = root.left
else:
peekNode = s[-1]
if peekNode.right and lastVisited != peekNode.right:
root = peekNode.right
else:
res.append(peekNode.data)
lastVisited = s.pop()
return res
# Driver program to test above functions
if __name__ == '__main__':
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)
print("Post order traversal of binary tree is:")
res = postOrder(root)
print("[", end='')
print(' '.join(map(str, res)), end='')
print("]")
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node left, right;
public Node(int val) {
data = val;
left = right = null;
}
}
class Program {
static List<int> PostOrder(Node root) {
List<int> res = new List<int>();
if (root == null) return res;
Stack<Node> s = new Stack<Node>();
Node lastVisited = null;
while (s.Count > 0 || root != null) {
if (root != null) {
s.Push(root);
root = root.left;
} else {
Node peekNode = s.Peek();
if (peekNode.right != null && lastVisited != peekNode.right) {
root = peekNode.right;
} else {
res.Add(peekNode.data);
lastVisited = s.Pop();
}
}
}
return res;
}
static void Main() {
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);
Console.WriteLine("Post order traversal of binary tree is:");
List<int> res = PostOrder(root);
Console.Write("[");
Console.Write(string.Join(" ", res));
Console.WriteLine("]");
}
}
class Node {
constructor(val) {
this.data = val;
this.left = null;
this.right = null;
}
}
function postOrder(root) {
let res = [];
if (root === null) {
return res;
}
let s = [];
let lastVisited = null;
while (s.length > 0 || root) {
if (root) {
s.push(root);
root = root.left;
} else {
let peekNode = s[s.length - 1];
if (peekNode.right && lastVisited !== peekNode.right) {
root = peekNode.right;
} else {
res.push(peekNode.data);
lastVisited = s.pop();
}
}
}
return res;
}
// Driver program to test above functions
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);
console.log("Post order traversal of binary tree is:");
let res = postOrder(root);
console.log('[', res.join(' '), ']');
OutputPost order traversal of binary tree is:
[4 5 2 6 7 3 1 ]
Similar Reads
Stack Data Structure A Stack is a linear data structure that follows a particular order in which the operations are performed. The order may be LIFO(Last In First Out) or FILO(First In Last Out). LIFO implies that the element that is inserted last, comes out first and FILO implies that the element that is inserted first
3 min read
What is Stack Data Structure? A Complete Tutorial Stack is a linear data structure that follows LIFO (Last In First Out) Principle, the last element inserted is the first to be popped out. It means both insertion and deletion operations happen at one end only. LIFO(Last In First Out) PrincipleHere are some real world examples of LIFOConsider a stac
4 min read
Applications, Advantages and Disadvantages of Stack A stack is a linear data structure in which the insertion of a new element and removal of an existing element takes place at the same end represented as the top of the stack.Stack Data StructureApplications of Stacks:Function calls: Stacks are used to keep track of the return addresses of function c
2 min read
Implement a stack using singly linked list To implement a stack using a singly linked list, we need to ensure that all operations follow the LIFO (Last In, First Out) principle. This means that the most recently added element is always the first one to be removed. In this approach, we use a singly linked list, where each node contains data a
13 min read
Introduction to Monotonic Stack - Data Structure and Algorithm Tutorials A monotonic stack is a special data structure used in algorithmic problem-solving. Monotonic Stack maintaining elements in either increasing or decreasing order. It is commonly used to efficiently solve problems such as finding the next greater or smaller element in an array etc.Monotonic StackTable
12 min read
Difference Between Stack and Queue Data Structures In computer science, data structures are fundamental concepts that are crucial for organizing and storing data efficiently. Among the various data structures, stacks and queues are two of the most basic yet essential structures used in programming and algorithm design. Despite their simplicity, they
4 min read
Stack implementation in different language
Stack in C++ STLIn C++, stack container follows LIFO (Last In First Out) order of insertion and deletion. It means that most recently inserted element is removed first and the first inserted element will be removed last. This is done by inserting and deleting elements at only one end of the stack which is generally
5 min read
Stack Class in JavaThe Java Collection framework provides a Stack class, which implements a Stack data structure. The class is based on the basic principle of LIFO (last-in-first-out). Besides the basic push and pop operations, the class also provides three more functions, such as empty, search, and peek. The Stack cl
11 min read
Stack in PythonA stack is a linear data structure that stores items in a Last-In/First-Out (LIFO) or First-In/Last-Out (FILO) manner. In stack, a new element is added at one end and an element is removed from that end only. The insert and delete operations are often called push and pop. The functions associated wi
8 min read
C# Stack with ExamplesIn C# a Stack is a Collection that follows the Last-In-First-Out (LIFO) principle. It is used when we need last-in, first-out access to items. In C# there are both generic and non-generic types of Stacks. The generic stack is in the System.Collections.Generic namespace, while the non-generic stack i
6 min read
Implementation of Stack in JavaScriptA stack is a fundamental data structure in computer science that follows the Last In, First Out (LIFO) principle. This means that the last element added to the stack will be the first one to be removed. Stacks are widely used in various applications, such as function call management, undo mechanisms
4 min read
Stack in ScalaA stack is a data structure that follows the last-in, first-out(LIFO) principle. We can add or remove element only from one end called top. Scala has both mutable and immutable versions of a stack. Syntax : import scala.collection.mutable.Stack var s = Stack[type]() // OR var s = Stack(val1, val2, v
3 min read
Some questions related to Stack implementation
Design and Implement Special Stack Data StructureDesign a Data Structure SpecialStack that supports all the stack operations like push(), pop(), isEmpty(), isFull() and an additional operation getMin() which should return minimum element from the SpecialStack. All these operations of SpecialStack must be O(1). To implement SpecialStack, you should
1 min read
Implement two Stacks in an ArrayCreate a data structure twoStacks that represent two stacks. Implementation of twoStacks should use only one array, i.e., both stacks should use the same array for storing elements. Following functions must be supported by twoStacks.push1(int x) --> pushes x to first stack push2(int x) --> pus
12 min read
Implement Stack using QueuesImplement a stack using queues. The stack should support the following operations:Push(x): Push an element onto the stack.Pop(): Pop the element from the top of the stack and return it.A Stack can be implemented using two queues. Let Stack to be implemented be 's' and queues used to implement are 'q
15+ min read
Implement k stacks in an arrayGiven an array of size n, the task is to implement k stacks using a single array. We mainly need to perform the following type of queries on the stack.push(x, i) : This operations pushes the element x into stack i pop(i) : This operation pops the top of stack iHere i varies from 0 to k-1Naive Approa
15+ min read
Design a stack that supports getMin() in O(1) timeDesign a Data Structure SpecialStack that supports all the stack operations like push(), pop(), peek() and an additional operation getMin() which should return minimum element from the SpecialStack. All these operations of SpecialStack must have a time complexity of O(1). Example: Input: queries = [
15+ min read
Implement a stack using single queueWe are given a queue data structure, the task is to implement a stack using a single queue.Also Read: Stack using two queuesThe idea is to keep the newly inserted element always at the front of the queue, preserving the order of previous elements by appending the new element at the back and rotating
5 min read
How to implement stack using priority queue or heap?How to Implement stack using a priority queue(using min heap)? Asked In: Microsoft, Adobe. Solution: In the priority queue, we assign priority to the elements that are being pushed. A stack requires elements to be processed in the Last in First Out manner. The idea is to associate a count that dete
6 min read
Create a customized data structure which evaluates functions in O(1)Create a customized data structure such that it has functions :- GetLastElement(); RemoveLastElement(); AddElement() GetMin() All the functions should be of O(1) Question Source : amazon interview questions Approach : create a custom stack of type structure with two elements, (element, min_till_now)
7 min read
Implement Stack and Queue using DequeDeque also known as double ended queue, as name suggests is a special kind of queue in which insertions and deletions can be done at the last as well as at the beginning. A link-list representation of deque is such that each node points to the next node as well as the previous node. So that insertio
15 min read
Easy problems on Stack
Infix to Postfix ExpressionWrite a program to convert an Infix expression to Postfix form.Infix expression: The expression of the form "a operator b" (a + b) i.e., when an operator is in-between every pair of operands.Postfix expression: The expression of the form "a b operator" (ab+) i.e., When every pair of operands is foll
9 min read
Prefix to Infix ConversionInfix : An expression is called the Infix expression if the operator appears in between the operands in the expression. Simply of the form (operand1 operator operand2). Example : (A+B) * (C-D)Prefix : An expression is called the prefix expression if the operator appears in the expression before the
6 min read
Prefix to Postfix ConversionGiven a Prefix expression, convert it into a Postfix expression. Conversion of Prefix expression directly to Postfix without going through the process of converting them first to Infix and then to Postfix is much better in terms of computation and better understanding the expression (Computers evalu
6 min read
Postfix to Prefix ConversionPostfix: An expression is called the postfix expression if the operator appears in the expression after the operands. Simply of the form (operand1 operand2 operator). Example : AB+CD-* (Infix : (A+B) * (C-D) )Prefix : An expression is called the prefix expression if the operator appears in the expre
7 min read
Postfix to InfixPostfix to infix conversion involves transforming expressions where operators follow their operands (postfix notation) into standard mathematical expressions with operators placed between operands (infix notation). This conversion improves readability and understanding.Infix expression: The expressi
5 min read
Convert Infix To Prefix NotationGiven an infix expression consisting of operators (+, -, *, /, ^) and operands (lowercase characters), the task is to convert it to a prefix expression.Infix Expression: The expression of type a 'operator' b (a+b, where + is an operator) i.e., when the operator is between two operands.Prefix Express
8 min read
Valid Parentheses in an ExpressionGiven a string s representing an expression containing various types of brackets: {}, (), and [], the task is to determine whether the brackets in the expression are balanced or not. A balanced expression is one where every opening bracket has a corresponding closing bracket in the correct order.Exa
8 min read
Arithmetic Expression EvaluationThe stack organization is very effective in evaluating arithmetic expressions. Expressions are usually represented in what is known as Infix notation, in which each operator is written between two operands (i.e., A + B). With this notation, we must distinguish between ( A + B )*C and A + ( B * C ) b
2 min read
Evaluation of Postfix ExpressionGiven a postfix expression, the task is to evaluate the postfix expression. A Postfix expression is of the form "a b operator" ("a b +") i.e., a pair of operands is followed by an operator.Examples:Input: arr = ["2", "3", "1", "*", "+", "9", "-"]Output: -4Explanation: If the expression is converted
6 min read
How to Reverse a Stack using RecursionWrite a program to reverse a stack using recursion, without using any loop.Example: Input: elements present in stack from top to bottom 4 3 2 1Output: 1 2 3 4Input: elements present in stack from top to bottom 1 2 3Output: 3 2 1The idea of the solution is to hold all values in Function Call Stack un
4 min read
Reverse individual wordsGiven string str, we need to print the reverse of individual words.Examples: Input: Hello WorldOutput: olleH dlroWExplanation: Each word in "Hello World" is reversed individually, preserving the original order, resulting in "olleH dlroW".Input: Geeks for GeeksOutput: skeeG rof skeeG[Expected Approac
5 min read
Reverse a String using StackGiven a string str, the task is to reverse it using stack. Example:Input: s = "GeeksQuiz"Output: ziuQskeeGInput: s = "abc"Output: cbaAlso read: Reverse a String – Complete Tutorial.As we all know, stacks work on the principle of first in, last out. After popping all the elements and placing them bac
3 min read
Reversing a QueueYou are given a queue Q, and your task is to reverse the elements of the queue. You are only allowed to use the following standard queue operations:enqueue(x): Add an item x to the rear of the queue.dequeue(): Remove an item from the front of the queue.empty(): Check if the queue is empty or not.Exa
4 min read
Intermediate problems on Stack
How to create mergeable stack?Design a stack with the following operations. push(Stack s, x): Adds an item x to stack s pop(Stack s): Removes the top item from stack s merge(Stack s1, Stack s2): Merge contents of s2 into s1. Time Complexity of all above operations should be O(1). If we use array implementation of the stack, then
8 min read
The Stock Span ProblemThe stock span problem is a financial problem where we have a series of daily price quotes for a stock denoted by an array arr[] and the task is to calculate the span of the stock's price for all days. The span of the stock's price on ith day represents the maximum number of consecutive days leading
11 min read
Next Greater Element (NGE) for every element in given ArrayGiven an array arr[] of integers, the task is to find the Next Greater Element for each element of the array in order of their appearance in the array. Note: The Next Greater Element for an element x is the first greater element on the right side of x in the array. Elements for which no greater elem
9 min read
Next Greater Frequency ElementGiven an array, for each element find the value of the nearest element to the right which is having a frequency greater than that of the current element. If there does not exist an answer for a position, then make the value '-1'.Examples: Input: arr[] = [2, 1, 1, 3, 2, 1]Output: [1, -1, -1, 2, 1, -1
9 min read
Maximum product of indexes of next greater on left and rightGiven an array arr[1..n], for each element at position i (1 <= i <= n), define the following:left(i) is the closest index j such that j < i and arr[j] > arr[i]. If no such j exists, then left(i) = 0.right(i) is the closest index k such that k > i and arr[k] > arr[i]. If no such k e
11 min read
Iterative Tower of HanoiThe Tower of Hanoi is a mathematical puzzle with three poles and stacked disks of different sizes. The goal is to move all disks from the source pole to the destination pole using an auxiliary pole, following two rules:Only one disk can be moved at a time.A larger disk cannot be placed on a smaller
6 min read
Sort a stack using a temporary stackGiven a stack of integers, sort it in ascending order using another temporary stack.Examples: Input: [34, 3, 31, 98, 92, 23]Output: [3, 23, 31, 34, 92, 98]Explanation: After Sorting the given array it would be look like as [3, 23, 31, 34, 92, 98]Input: [3, 5, 1, 4, 2, 8]Output: [1, 2, 3, 4, 5, 8] Ap
6 min read
Reverse a stack without using extra space in O(n)Reverse a Stack without using recursion and extra space. Even the functional Stack is not allowed. Examples: Input : 1->2->3->4 Output : 4->3->2->1 Input : 6->5->4 Output : 4->5->6 We have discussed a way of reversing a stack in the below post.Reverse a Stack using Recu
6 min read
Delete middle element of a stackGiven a stack with push(), pop(), and empty() operations, The task is to delete the middle element of it without using any additional data structure.Input: s = [10, 20, 30, 40, 50]Output: [50, 40, 20, 10]Explanation: The bottom-most element will be 10 and the top-most element will be 50. Middle elem
8 min read
Check if a queue can be sorted into another queue using a stackGiven a Queue consisting of first n natural numbers (in random order). The task is to check whether the given Queue elements can be arranged in increasing order in another Queue using a stack. The operation allowed are: Push and pop elements from the stack Pop (Or Dequeue) from the given Queue. Push
9 min read
Check if an array is stack sortableGiven an array arr[] of n distinct elements, where each element is between 1 and n (inclusive), determine if it is stack-sortable.Note: An array a[] is considered stack-sortable if it can be rearranged into a sorted array b[] using a temporary stack stk with the following operations:Remove the first
6 min read
Largest Rectangular Area in a HistogramGiven a histogram represented by an array arr[], where each element of the array denotes the height of the bars in the histogram. All bars have the same width of 1 unit.Task is to find the largest rectangular area possible in a given histogram where the largest rectangle can be made of a number of c
15+ min read
Maximum of minimums of every window size in a given arrayGiven an integer array arr[] of size n, the task is to find the maximum of the minimums for every window size in the given array, where the window size ranges from 1 to n.Example:Input: arr[] = [10, 20, 30]Output: [30, 20, 10]Explanation: First element in output indicates maximum of minimums of all
14 min read
Find index of closing bracket for a given opening bracket in an expressionGiven a string with brackets. If the start index of the open bracket is given, find the index of the closing bracket. Examples: Input : string = [ABC[23]][89] index = 0 Output : 8 The opening bracket at index 0 corresponds to closing bracket at index 8.Recommended PracticeClosing bracket indexTry It
7 min read
Maximum difference between nearest left and right smaller elementsGiven an array of integers, the task is to find the maximum absolute difference between the nearest left and the right smaller element of every element in the array. Note: If there is no smaller element on right side or left side of any element then we take zero as the smaller element. For example f
12 min read
Delete consecutive same words in a sequenceGiven an array of n strings arr[]. The task is to determine the number of words remaining after pairwise destruction. If two consecutive words in the array are identical, they cancel each other out. This process continues until no more eliminations are possible. Examples: Input: arr[] = ["gfg", "for
7 min read
Check mirror in n-ary treeGiven two n-ary trees, determine whether they are mirror images of each other. Each tree is described by e edges, where e denotes the number of edges in both trees. Two arrays A[]and B[] are provided, where each array contains 2*e space-separated values representing the edges of both trees. Each edg
11 min read
Reverse a number using stackGiven a number , write a program to reverse this number using stack.Examples: Input : 365Output : 563Input : 6899Output : 9986We have already discussed the simple method to reverse a number in this post. In this post we will discuss about how to reverse a number using stack.The idea to do this is to
5 min read
Reversing the first K elements of a QueueGiven an integer k and a queue of integers, The task is to reverse the order of the first k elements of the queue, leaving the other elements in the same relative order.Only following standard operations are allowed on the queue. enqueue(x): Add an item x to rear of queuedequeue(): Remove an item fr
13 min read