Skip to content
geeksforgeeks
  • Tutorials
    • Python
    • Java
    • Data Structures & Algorithms
    • ML & Data Science
    • Interview Corner
    • Programming Languages
    • Web Development
    • CS Subjects
    • DevOps And Linux
    • School Learning
    • Practice Coding Problems
  • Courses
    • DSA to Development
    • Get IBM Certification
    • Newly Launched!
      • Master Django Framework
      • Become AWS Certified
    • For Working Professionals
      • Interview 101: DSA & System Design
      • Data Science Training Program
      • JAVA Backend Development (Live)
      • DevOps Engineering (LIVE)
      • Data Structures & Algorithms in Python
    • For Students
      • Placement Preparation Course
      • Data Science (Live)
      • Data Structure & Algorithm-Self Paced (C++/JAVA)
      • Master Competitive Programming (Live)
      • Full Stack Development with React & Node JS (Live)
    • Full Stack Development
    • Data Science Program
    • All Courses
  • DSA
  • Interview Problems on Stack
  • Practice Stack
  • MCQs on Stack
  • Stack Tutorial
  • Stack Operations
  • Stack Implementations
  • Monotonic Stack
  • Infix to Postfix
  • Prefix to Postfix
  • Prefix to Infix
  • Advantages & Disadvantages
Open In App
Next Article:
Design a stack that supports getMin() in O(1) time
Next article icon

Implement k stacks in an array

Last Updated : 10 Apr, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report

Given 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 i

Here i varies from 0 to k-1

Naive Approach - Dividing Array into k Segments

The idea is to divide the array of size n into k equal segments, each of size n/k. Each segment acts as a dedicated space for one of the k stacks. We maintain k different top pointers (top[0] through top[k-1]), one for each stack, and initialize them to point to the start of their respective segments minus 1 (to indicate empty stacks). When pushing an element to stack i, we increment top[i] and place the element at that index. For popping from stack i, we return the element at top[i] and decrement top[i].

The main drawback is that it allocates a fixed amount of space for each stack regardless of their actual usage. If one stack requires more space than its allocated n/k elements while another stack is mostly empty, we still can't use the empty space from one stack for the overflow of another. This leads to "internal fragmentation" where some stacks might overflow even though there's plenty of unused space in the array overall, making poor use of the available memory.

_Division-of-an-Array-to-Implement-k-Stacks
Dividing array into k segments
C++ 
#include <bits/stdc++.h> using namespace std;  class kStacks { private:     vector<int> arr;     int n, k;     vector<int> top;     vector<int> next;     int freeIndex;      public:     kStacks(int n, int k) {         this->n = n;         this->k = k;         arr.resize(n);         top.resize(k, -1);         next.resize(n);                  // Initialize all spaces as free         freeIndex = 0;         for (int i = 0; i < n - 1; i++) {             next[i] = i + 1;         }         next[n - 1] = -1;     }          // Function to push element x into m'th stack     bool push(int x, int m) {                  // Check if there is space available in the stack         if (freeIndex == -1) {             return false;           }                  // Get the index of the free space         int i = freeIndex;                  // Update freeIndex to the next free slot         freeIndex = next[i];                  // Insert the element into the correct stack         next[i] = top[m];         top[m] = i;         arr[i] = x;                  return true;     }          // Function to pop top element from m'th stack     int pop(int m) {         if (top[m] == -1) {             return -1;          }                  // Get the top element from stack m         int i = top[m];                  // Update the top of stack m         top[m] = next[i];                  // Return the popped element and update the freeIndex         next[i] = freeIndex;         freeIndex = i;                  return arr[i];     } };  int main() {     int n = 5, k = 4;     kStacks* s = new kStacks(n, k);               vector<vector<int>> queries = {         {1, 15, 0},           {1, 25, 1},           {1, 35, 2},           {1, 45, 3},           {1, 55, 0},         {2, 0},              {2, 1},              {1, 55, 0},           {2, 3}           };          for (auto q : queries) {         if (q[0] == 1) {             if (s->push(q[1], q[2])) {                 cout << 1 << " ";             } else {                 cout << 0 << " ";             }         } else {             cout << s->pop(q[1]) << " ";         }     }      return 0; }
Java 
import java.util.*;  class kStacks {     private int[] arr;     private int[] top;     private int[] next;     private int freeIndex;     private int n, k;      public kStacks(int n, int k) {         this.n = n;         this.k = k;         arr = new int[n];         top = new int[k];         next = new int[n];          // Initialize all stacks as empty         Arrays.fill(top, -1);         freeIndex = 0;         for (int i = 0; i < n - 1; i++) {             next[i] = i + 1;         }         next[n - 1] = -1;     }      // Function to push element x into m'th stack     public boolean push(int x, int m) {                  // Check if there is space available in the stack         if (freeIndex == -1) {             return false;           }          // Get the index of the free space         int i = freeIndex;          // Update freeIndex to the next free slot         freeIndex = next[i];          // Insert the element into the correct stack         next[i] = top[m];         top[m] = i;         arr[i] = x;          return true;     }      // Function to pop top element from m'th stack     public int pop(int m) {                  // Check if the stack is empty         if (top[m] == -1) {             return -1;           }          // Get the top element from stack m         int i = top[m];          // Update the top of stack m         top[m] = next[i];          // Return the popped element and update the freeIndex         next[i] = freeIndex;         freeIndex = i;          return arr[i];     }      public static void main(String[] args) {         int n = 5, k = 4;         kStacks s = new kStacks(n, k);          int[][] queries = {             {1, 15, 0},             {1, 25, 1},             {1, 35, 2},             {1, 45, 3},             {1, 55, 0},             {2, 0},             {2, 1},             {1, 55, 0},             {2, 3}         };          for (int[] q : queries) {             if (q[0] == 1) {                 if (s.push(q[1], q[2])) {                     System.out.print(1 + " ");                 } else {                     System.out.print(0 + " ");                 }             } else {                 System.out.print(s.pop(q[1]) + " ");             }         }     } }
Python 
class kStacks:     def __init__(self, n, k):         self.n = n         self.k = k         self.arr = [0] * n         self.top = [-1] * k         self.next = list(range(1, n)) + [-1]         self.freeIndex = 0      # Function to push element x into m'th stack     def push(self, x, m):                  # Check if there is space available in the stack         if self.freeIndex == -1:             return False            # Get the index of the free space         i = self.freeIndex          # Update freeIndex to the next free slot         self.freeIndex = self.next[i]          # Insert the element into the correct stack         self.next[i] = self.top[m]         self.top[m] = i         self.arr[i] = x          return True      # Function to pop top element from m'th stack     def pop(self, m):                  # Check if the stack is empty         if self.top[m] == -1:             return -1            # Get the top element from stack m         i = self.top[m]          # Update the top of stack m         self.top[m] = self.next[i]          # Return the popped element and update the freeIndex         self.next[i] = self.freeIndex         self.freeIndex = i          return self.arr[i]  if __name__ == '__main__':     n = 5     k = 4     s = kStacks(n, k)      queries = [         [1, 15, 0],         [1, 25, 1],         [1, 35, 2],         [1, 45, 3],         [1, 55, 0],         [2, 0],         [2, 1],         [1, 55, 0],         [2, 3]     ]      for q in queries:         if q[0] == 1:             if s.push(q[1], q[2]):                 print(1, end=' ')             else:                 print(0, end=' ')         else:             print(s.pop(q[1]), end=' ')
C# 
using System; using System.Collections.Generic;  class kStacks {     private List<int> arr;     private List<int> top;     private List<int> next;     private int freeIndex;      public kStacks(int n, int k) {         arr = new List<int>(new int[n]);         top = new List<int>(new int[k]);         next = new List<int>(new int[n]);          // Initialize all spaces as free         freeIndex = 0;         for (int i = 0; i < n - 1; i++) {             next[i] = i + 1;         }         next[n - 1] = -1;       }      // Function to push element x into m'th stack     public bool Push(int x, int m) {                  // Check if there is space available in the stack         if (freeIndex == -1) {             return false;           }          // Get the index of the free space         int i = freeIndex;          // Update freeIndex to the next free slot         freeIndex = next[i];          // Insert the element into the correct stack         next[i] = top[m];         top[m] = i;         arr[i] = x;          return true;     }      // Function to pop top element from m'th stack     public int Pop(int m) {         // Check if the stack is empty         if (top[m] == -1) {             return -1;  // Stack is empty         }          // Get the top element from stack m         int i = top[m];          // Update the top of stack m         top[m] = next[i];          // Return the popped element and update the freeIndex         next[i] = freeIndex;         freeIndex = i;          return arr[i];     } }  class Program {     static void Main() {         int n = 5, k = 4;         kStacks s = new kStacks(n, k);          List<List<int>> queries = new List<List<int>>() {             new List<int> {1, 15, 0},             new List<int> {1, 25, 1},             new List<int> {1, 35, 2},             new List<int> {1, 45, 3},             new List<int> {1, 55, 0},             new List<int> {2, 0},             new List<int> {2, 1},             new List<int> {1, 55, 0},             new List<int> {2, 3}         };          foreach (var q in queries) {             if (q[0] == 1) {                 Console.Write((s.Push(q[1], q[2]) ? 1 : 0) + " ");             } else {                 Console.Write(s.Pop(q[1]) + " ");             }         }     } }
JavaScript 
class kStacks {     constructor(n, k) {         this.n = n;         this.k = k;         this.arr = new Array(n);         this.top = new Array(k).fill(-1);         this.next = new Array(n);         this.freeIndex = 0;          // Initialize all spaces as free         for (let i = 0; i < n - 1; i++) {             this.next[i] = i + 1;         }         this.next[n - 1] = -1;     }      // Function to push element x into m'th stack     push(x, m) {                  // Check if there is space available in the stack         if (this.freeIndex === -1) {             return false;           }          // Get the index of the free space         let i = this.freeIndex;          // Update freeIndex to the next free slot         this.freeIndex = this.next[i];          // Insert the element into the correct stack         this.next[i] = this.top[m];         this.top[m] = i;         this.arr[i] = x;          return true;     }      // Function to pop top element from m'th stack     pop(m) {                  // Check if the stack is empty         if (this.top[m] === -1) {             return -1;           }          // Get the top element from stack m         let i = this.top[m];          // Update the top of stack m         this.top[m] = this.next[i];          // Return the popped element and update the freeIndex         this.next[i] = this.freeIndex;         this.freeIndex = i;          return this.arr[i];     } }  let n = 5, k = 4; let s = new kStacks(n, k);  let queries = [     [1, 15, 0],     [1, 25, 1],     [1, 35, 2],     [1, 45, 3],     [1, 55, 0],     [2, 0],     [2, 1],     [1, 55, 0],     [2, 3] ];  for (let q of queries) {     if (q[0] === 1) {         process.stdout.write((s.push(q[1], q[2]) ? 1 : 0) + " ");     } else {         process.stdout.write(s.pop(q[1]) + " ");     } }

Output
1 1 1 1 0 15 25 1 45

Time Complexity:

  • O(1) for push operation.
  • O(1) for pop operation.

Auxiliary Space: O(n), where n is the size of array.

Efficient Approach - Using Space Optimized Method

The idea is to use a single array for storing elements of all stacks along with an auxiliary array that maintains pointers to the next element in each stack. Instead of dividing the array into fixed segments, we implement a free list structure that keeps track of available spaces in the array.

Following are the two extra arrays are used: 

1) top[]:This is of size k and stores indexes of top elements in all stacks. top[i] = -1 indicates an empty stack.

2) next[]: This is of size n and stores indexes of next item for the items in array arr[]. For stack elements, it points to the next stack element index and for free index, it indicates the index of next free index.

Algorithm:

  1. Initialize an array top of size k to keep track of the top element of each stack. Set top[i] = -1 for all 0 ≤ i < k to indicate empty stacks.
  2. Initialize an array next of size n to link elements in the same stack and maintain a free list. Set next[i] = i+1 for all 0 ≤ i < n-1, and next[n-1] = -1.
  3. Initialize a variable free = 0 to point to the first available position in the free list.
  4. To push an element onto the m-th stack:
    • Check if the array is full by checking if free is -1. If it is, return false.
    • Store the current free index, update free = next[free] to point to the next available slot.
    • Link the new element to the current stack by setting next[current_index] = top[m].
    • Update the top of the stack to the new element: top[m] = current_index.
    • Store the value in the array at the allocated position.
  5. To pop an element from the m-th stack:
    • Check if the stack is empty by checking if top[m] is -1. If it is, return -1.
    • Get the index of the top element: i = top[m].
    • Update the top to the next element in the stack: top[m] = next[i].
    • Return the element to the free list by setting next[i] = free and free = i.
    • Return the element value.


C++ 
// C++ program to implement k stacks in an array. #include <bits/stdc++.h> using namespace std; class kStacks { private:     vector<int> arr;        int n, k;               vector<int> top;        vector<int> next;       int freeIndex;           public:       // Constructor to initialize kStacks     kStacks(int n, int k) {         this->n = n;         this->k = k;         arr.resize(n);         top.resize(k, -1);         next.resize(n);                  // Initialize all spaces as free         freeIndex = 0;         for (int i = 0; i < n-1; i++)             next[i] = i + 1;                      // -1 is used to indicate end of free list         next[n-1] = -1;       }          // Function to push element x into     // m'th stack     bool push(int x, int m) {                  // Check if we have space for a new element         if (freeIndex == -1) {             return false;           }                  // Store index of first free slot         int i = freeIndex;                  // Update free to point to next slot in free list         freeIndex = next[i];                  // Update next of top and then top for stack m         next[i] = top[m];         top[m] = i;                  // Store the item in array         arr[i] = x;                  return true;     }          // Function to pop top element from      // m'th stack.     int pop(int m) {                  // Check if stack is empty         if (top[m] == -1) {             return -1;           }                  // Find index of top item in stack m         int i = top[m];                  // Update top of stack m         top[m] = next[i];                  // Add the previous top to free list         next[i] = freeIndex;         freeIndex = i;                  // Return the popped element         return arr[i];     } };  int main() {     int n = 5, k = 4;     kStacks* s = new kStacks(n, k);          // Each query is of either 2 types     // 1: Push operation -> {1, x, m}     // 2: Pop operation -> {2, m}     vector<vector<int>> queries = {         {1, 15, 0},           {1, 25, 1},           {1, 35, 2},           {1, 45, 3},           {1, 55, 0},         {2, 0},              {2, 1},              {1, 55, 0},           {2, 3}           };          for (auto q: queries) {                  if (q[0] == 1) {             if (s->push(q[1], q[2])) {                 cout << 1 << " ";             } else {                 cout << 0 << " ";             }         }         else {             cout << s->pop(q[1]) << " ";         }     }     return 0; }
Java 
// Java program to implement k stacks in an array. import java.util.*;  class kStacks {     int[] arr;        int n, k;               int[] top;        int[] next;       int freeIndex;                // Constructor to initialize kStacks     kStacks(int n, int k) {         this.n = n;         this.k = k;         arr = new int[n];         top = new int[k];         next = new int[n];         Arrays.fill(top, -1);                  // Initialize all spaces as free         freeIndex = 0;         for (int i = 0; i < n - 1; i++)             next[i] = i + 1;                      // -1 is used to indicate end of free list         next[n - 1] = -1;       }      // Function to push element x into     // m'th stack     boolean push(int x, int m) {          // Check if we have space for a new element         if (freeIndex == -1) {             return false;           }          // Store index of first free slot         int i = freeIndex;          // Update free to point to next slot in free list         freeIndex = next[i];          // Update next of top and then top for stack m         next[i] = top[m];         top[m] = i;          // Store the item in array         arr[i] = x;          return true;     }      // Function to pop top element from      // m'th stack.     int pop(int m) {          // Check if stack is empty         if (top[m] == -1) {             return -1;           }          // Find index of top item in stack m         int i = top[m];          // Update top of stack m         top[m] = next[i];          // Add the previous top to free list         next[i] = freeIndex;         freeIndex = i;          // Return the popped element         return arr[i];     } }  class GfG {     public static void main(String[] args) {         int n = 5, k = 4;         kStacks s = new kStacks(n, k);          // Each query is of either 2 types         // 1: Push operation -> {1, x, m}         // 2: Pop operation -> {2, m}         int[][] queries = {             {1, 15, 0},               {1, 25, 1},               {1, 35, 2},               {1, 45, 3},               {1, 55, 0},             {2, 0},                  {2, 1},                  {1, 55, 0},               {2, 3}               };          for (int[] q : queries) {             if (q[0] == 1) {                 if (s.push(q[1], q[2])) {                     System.out.print(1 + " ");                 } else {                     System.out.print(0 + " ");                 }             } else {                 System.out.print(s.pop(q[1]) + " ");             }         }     } }
Python 
# Python program to implement k stacks in an array. class kStacks:          # Constructor to initialize kStacks     def __init__(self, n, k):         self.n = n         self.k = k         self.arr = [0] * n         self.top = [-1] * k         self.next = [0] * n          # Initialize all spaces as free         self.freeIndex = 0         for i in range(n - 1):             self.next[i] = i + 1          # -1 is used to indicate end of free list         self.next[n - 1] = -1      # Function to push element x into     # m'th stack     def push(self, x, m):          # Check if we have space for a new element         if self.freeIndex == -1:             return False          # Store index of first free slot         i = self.freeIndex          # Update free to point to next slot in free list         self.freeIndex = self.next[i]          # Update next of top and then top for stack m         self.next[i] = self.top[m]         self.top[m] = i          # Store the item in array         self.arr[i] = x          return True      # Function to pop top element from      # m'th stack.     def pop(self, m):          # Check if stack is empty         if self.top[m] == -1:             return -1          # Find index of top item in stack m         i = self.top[m]          # Update top of stack m         self.top[m] = self.next[i]          # Add the previous top to free list         self.next[i] = self.freeIndex         self.freeIndex = i          # Return the popped element         return self.arr[i]   if __name__ == "__main__":     n, k = 5, 4     s = kStacks(n, k)      # Each query is of either 2 types     # 1: Push operation -> {1, x, m}     # 2: Pop operation -> {2, m}     queries = [         [1, 15, 0],         [1, 25, 1],         [1, 35, 2],         [1, 45, 3],         [1, 55, 0],         [2, 0],         [2, 1],         [1, 55, 0],         [2, 3]     ]      for q in queries:         if q[0] == 1:             if s.push(q[1], q[2]):                 print(1, end=" ")             else:                 print(0, end=" ")         else:             print(s.pop(q[1]), end=" ")
C# 
// C# program to implement k stacks in an array. using System; using System.Collections.Generic;  class kStacks {     int[] arr;        int n, k;               int[] top;        int[] next;       int freeIndex;                // Constructor to initialize kStacks     public kStacks(int n, int k) {         this.n = n;         this.k = k;         arr = new int[this.n];         top = new int[this.k];         next = new int[this.n];         for (int i = 0; i < k; i++) top[i] = -1;          // Initialize all spaces as free         freeIndex = 0;         for (int i = 0; i < n - 1; i++)             next[i] = i + 1;          // -1 is used to indicate end of free list         next[n - 1] = -1;     }      // Function to push element x into     // m'th stack     public bool push(int x, int m) {          // Check if we have space for a new element         if (freeIndex == -1) {             return false;         }          // Store index of first free slot         int i = freeIndex;          // Update free to point to next slot in free list         freeIndex = next[i];          // Update next of top and then top for stack m         next[i] = top[m];         top[m] = i;          // Store the item in array         arr[i] = x;          return true;     }      // Function to pop top element from      // m'th stack.     public int pop(int m) {          // Check if stack is empty         if (top[m] == -1) {             return -1;         }          // Find index of top item in stack m         int i = top[m];          // Update top of stack m         top[m] = next[i];          // Add the previous top to free list         next[i] = freeIndex;         freeIndex = i;          // Return the popped element         return arr[i];     } }  class GfG {     static void Main(string[] args) {         int n = 5, k = 4;         kStacks s = new kStacks(n, k);          // Each query is of either 2 types         // 1: Push operation -> {1, x, m}         // 2: Pop operation -> {2, m}         List<List<int>> queries = new List<List<int>> {             new List<int>{1, 15, 0},               new List<int>{1, 25, 1},               new List<int>{1, 35, 2},               new List<int>{1, 45, 3},               new List<int>{1, 55, 0},             new List<int>{2, 0},                  new List<int>{2, 1},                  new List<int>{1, 55, 0},               new List<int>{2, 3}               };          foreach (var q in queries) {             if (q[0] == 1) {                 if (s.push(q[1], q[2])) {                     Console.Write("1 ");                 } else {                     Console.Write("0 ");                 }             } else {                 Console.Write(s.pop(q[1]) + " ");             }         }     } }
Javascript 
// JavaScript program to implement k stacks in an array. class kStacks {     constructor(n, k) {         this.n = n;         this.k = k;         this.arr = new Array(n);         this.top = new Array(k).fill(-1);         this.next = new Array(n);          // Initialize all spaces as free         this.freeIndex = 0;         for (let i = 0; i < n - 1; i++) {             this.next[i] = i + 1;         }          // -1 is used to indicate end of free list         this.next[n - 1] = -1;     }      // Function to push element x into     // m'th stack     push(x, m) {         if (this.freeIndex === -1) {             return false;         }          let i = this.freeIndex;         this.freeIndex = this.next[i];         this.next[i] = this.top[m];         this.top[m] = i;         this.arr[i] = x;         return true;     }      // Function to pop top element from      // m'th stack.     pop(m) {         if (this.top[m] === -1) {             return -1;         }          let i = this.top[m];         this.top[m] = this.next[i];         this.next[i] = this.freeIndex;         this.freeIndex = i;         return this.arr[i];     } }  let n = 5, k = 4; let s = new kStacks(n, k);  // Each query is of either 2 types // 1: Push operation -> {1, x, m} // 2: Pop operation -> {2, m} let queries = [     [1, 15, 0],     [1, 25, 1],     [1, 35, 2],     [1, 45, 3],     [1, 55, 0],     [2, 0],     [2, 1],     [1, 55, 0],     [2, 3] ];  for (let q of queries) {     if (q[0] === 1) {         process.stdout.write((s.push(q[1], q[2]) ? "1" : "0") + " ");     } else {         process.stdout.write(s.pop(q[1]) + " ");     } }

Output
1 1 1 1 1 55 25 1 45

Time Complexity:

  • O(1) for push operation.
  • O(1) for pop operation.

Auxiliary Space: O(n), where n is the size of array.

Related Article:

  • Implement two Stacks in an Array

Next Article
Design a stack that supports getMin() in O(1) time

S

Sachin
Improve
Article Tags :
  • Stack
  • DSA
Practice Tags :
  • Stack

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++ STL
    In 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 Java
    The 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 Python
    A 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 Examples
    In 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 JavaScript
    A 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 Scala
    A 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 Structure
    Design 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 Array
    Create 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 Queues
    Implement 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 array
    Given 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) time
    Design 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 queue
    We 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 Deque
    Deque 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 Expression
    Write 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 Conversion
    Infix : 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 Conversion
    Given 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 Conversion
    Postfix: 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 Infix
    Postfix 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 Notation
    Given 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 Expression
    Given 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 Evaluation
    The 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 Expression
    Given 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 Recursion
    Write 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 words
    Given 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 Stack
    Given 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 Queue
    You 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 Problem
    The 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 Array
    Given 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 Element
    Given 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 right
    Given 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 Hanoi
    The 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 stack
    Given 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 stack
    Given 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 stack
    Given 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 sortable
    Given 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 Histogram
    Given 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 array
    Given 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 expression
    Given 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 elements
    Given 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 sequence
    Given 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 tree
    Given 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 stack
    Given 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 Queue
    Given 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
geeksforgeeks-footer-logo
Corporate & Communications Address:
A-143, 7th Floor, Sovereign Corporate Tower, Sector- 136, Noida, Uttar Pradesh (201305)
Registered Address:
K 061, Tower K, Gulshan Vivante Apartment, Sector 137, Noida, Gautam Buddh Nagar, Uttar Pradesh, 201305
GFG App on Play Store GFG App on App Store
Advertise with us
  • Company
  • About Us
  • Legal
  • Privacy Policy
  • In Media
  • Contact Us
  • Advertise with us
  • GFG Corporate Solution
  • Placement Training Program
  • Languages
  • Python
  • Java
  • C++
  • PHP
  • GoLang
  • SQL
  • R Language
  • Android Tutorial
  • Tutorials Archive
  • DSA
  • Data Structures
  • Algorithms
  • DSA for Beginners
  • Basic DSA Problems
  • DSA Roadmap
  • Top 100 DSA Interview Problems
  • DSA Roadmap by Sandeep Jain
  • All Cheat Sheets
  • Data Science & ML
  • Data Science With Python
  • Data Science For Beginner
  • Machine Learning
  • ML Maths
  • Data Visualisation
  • Pandas
  • NumPy
  • NLP
  • Deep Learning
  • Web Technologies
  • HTML
  • CSS
  • JavaScript
  • TypeScript
  • ReactJS
  • NextJS
  • Bootstrap
  • Web Design
  • Python Tutorial
  • Python Programming Examples
  • Python Projects
  • Python Tkinter
  • Python Web Scraping
  • OpenCV Tutorial
  • Python Interview Question
  • Django
  • Computer Science
  • Operating Systems
  • Computer Network
  • Database Management System
  • Software Engineering
  • Digital Logic Design
  • Engineering Maths
  • Software Development
  • Software Testing
  • DevOps
  • Git
  • Linux
  • AWS
  • Docker
  • Kubernetes
  • Azure
  • GCP
  • DevOps Roadmap
  • System Design
  • High Level Design
  • Low Level Design
  • UML Diagrams
  • Interview Guide
  • Design Patterns
  • OOAD
  • System Design Bootcamp
  • Interview Questions
  • Inteview Preparation
  • Competitive Programming
  • Top DS or Algo for CP
  • Company-Wise Recruitment Process
  • Company-Wise Preparation
  • Aptitude Preparation
  • Puzzles
  • School Subjects
  • Mathematics
  • Physics
  • Chemistry
  • Biology
  • Social Science
  • English Grammar
  • Commerce
  • World GK
  • GeeksforGeeks Videos
  • DSA
  • Python
  • Java
  • C++
  • Web Development
  • Data Science
  • CS Subjects
@GeeksforGeeks, Sanchhaya Education Private Limited, All rights reserved
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox
Improvement
Suggest Changes
Help us improve. Share your suggestions to enhance the article. Contribute your expertise and make a difference in the GeeksforGeeks portal.
geeksforgeeks-suggest-icon
Create Improvement
Enhance the article with your expertise. Contribute to the GeeksforGeeks community and help create better learning resources for all.
geeksforgeeks-improvement-icon
Suggest Changes
min 4 words, max Words Limit:1000

Thank You!

Your suggestions are valuable to us.

What kind of Experience do you want to share?

Interview Experiences
Admission Experiences
Career Journeys
Work Experiences
Campus Experiences
Competitive Exam Experiences