Skip to content

Implement a stack using single queue

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

Last Updated : 26 Apr, 2025

Try it on GfG Practice

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 = [push(2), push(3), peek(), pop(), getMin(), push(1), getMin()]
Output: [3, 2, 1]
Explanation:
push(2): Stack is [2]
push(3): Stack is [2, 3]
peek(): Top element is 3
pop(): Removes 3, stack is [2]
getMin(): Minimum element is 2
push(1): Stack is [2, 1]
getMin(): Minimum element is 1
Input: queries = [push(10), getMin(), push(5), getMin(), pop()]
Output: [10, 5]
Explanation:
push(10): Stack is [10]
getMin(): Minimum element is 10
push(5): Stack is [10, 5]
getMin(): Minimum element is 5
pop(): Removes 5, stack is [10]

Table of Content

Using an Auxiliary Stack - O(n) Time and O(n) Space

Use two stacks: one to store actual stack elements and the other as an auxiliary stack to store minimum values. The idea is to do push() and pop() operations in such a way that the top of the auxiliary stack is always the minimum. Let us see how push() and pop() operations work.

Push(int x)

push x to the first stack (the stack with actual elements)
compare x with the top element of the second stack (the auxiliary stack). Let the top element be y.
- If x is smaller than y then push x to the auxiliary stack.
- If x is greater than y then push y to the auxiliary stack.

int Pop()

pop the top element from the auxiliary stack.
pop the top element from the actual stack and return it. Step 1 is necessary to make sure that the auxiliary stack is also updated for future operations.

int getMin()

Return the top element of the auxiliary stack.

C++

#include <iostream> #include <stack> using namespace std;  class SpecialStack {     stack<int> s;      stack<int> minStack;   public:     void push(int x) {         s.push(x);                  // If the minStack is empty or the new element is smaller than          // the top of minStack, push it onto minStack         if (minStack.empty() || x <= minStack.top()) {             minStack.push(x);         } else {                          // Otherwise, push the top element of minStack              // again to keep the minimum unchanged             minStack.push(minStack.top());         }     }      // Pop the top element from the stack     int pop() {         if (s.empty()) {             return -1;         }         // Pop from both stacks         int poppedElement = s.top();         s.pop();         minStack.pop();         return poppedElement;     }      // Return the top element of the stack without removing it     int peek() {         if (s.empty()) {             return -1;         }         return s.top();     }      // Check if the stack is empty     bool isEmpty() {         return s.empty();     }      // Get the minimum element in the stack     int getMin() {         if (minStack.empty()) {             return -1;         }         return minStack.top();     } };  int main() {     SpecialStack stack;          stack.push(18);     stack.push(19);     stack.push(29);     stack.push(15);     stack.push(16);      cout << stack.getMin() << endl;      return 0; }

Java

import java.util.Stack;  class SpecialStack {     Stack<Integer> s = new Stack<>();     Stack<Integer> minStack = new Stack<>();      public void push(int x) {         s.push(x);         // If the minStack is empty or the new element is smaller than          // the top of minStack, push it onto minStack         if (minStack.isEmpty() || x <= minStack.peek()) {             minStack.push(x);         } else {             // Otherwise, push the top element of minStack              // again to keep the minimum unchanged             minStack.push(minStack.peek());         }     }      // Pop the top element from the stack     public int pop() {         if (s.isEmpty()) {             return -1;         }         // Pop from both stacks         int poppedElement = s.pop();         minStack.pop();         return poppedElement;     }      // Return the top element of the stack without removing it     public int peek() {         if (s.isEmpty()) {             return -1;         }         return s.peek();     }      // Check if the stack is empty     public boolean isEmpty() {         return s.isEmpty();     }      // Get the minimum element in the stack     public int getMin() {         if (minStack.isEmpty()) {             return -1;         }         return minStack.peek();     } }  public class GfG {     public static void main(String[] args) {         SpecialStack stack = new SpecialStack();                  stack.push(18);         stack.push(19);         stack.push(29);         stack.push(15);         stack.push(16);          System.out.println(stack.getMin());     } }

Python

class specialStack:     def __init__(self):         self.s = []         self.minStack = []      def push(self, x):         self.s.append(x)         # If the minStack is empty or the new element is smaller than          # the top of minStack, push it onto minStack         if not self.minStack or x <= self.minStack[-1]:             self.minStack.append(x)         else:             # Otherwise, push the top element of minStack              # again to keep the minimum unchanged             self.minStack.append(self.minStack[-1])      # Pop the top element from the stack     def pop(self):         if not self.s:             return -1         # Pop from both stacks         poppedElement = self.s.pop()         self.minStack.pop()         return poppedElement      # Return the top element of the stack without removing it     def peek(self):         if not self.s:             return -1         return self.s[-1]      # Check if the stack is empty     def isEmpty(self):         return len(self.s) == 0      # Get the minimum element in the stack     def getMin(self):         if not self.minStack:             return -1         return self.minStack[-1]  if __name__ == '__main__':     stack = specialStack()          stack.push(18)     stack.push(19)     stack.push(29)     stack.push(15)     stack.push(16)      print(stack.getMin())

C#

using System; using System.Collections.Generic;  class SpecialStack {     Stack<int> s = new Stack<int>();     Stack<int> minStack = new Stack<int>();      public void Push(int x) {         s.Push(x);         // If the minStack is empty or the new element is smaller than          // the top of minStack, push it onto minStack         if (minStack.Count == 0 || x <= minStack.Peek()) {             minStack.Push(x);         } else {             // Otherwise, push the top element of minStack              // again to keep the minimum unchanged             minStack.Push(minStack.Peek());         }     }      // Pop the top element from the stack     public int Pop() {         if (s.Count == 0) {             return -1;         }         // Pop from both stacks         int poppedElement = s.Pop();         minStack.Pop();         return poppedElement;     }      // Return the top element of the stack without removing it     public int Peek() {         if (s.Count == 0) {             return -1;         }         return s.Peek();     }      // Check if the stack is empty     public bool IsEmpty() {         return s.Count == 0;     }      // Get the minimum element in the stack     public int GetMin() {         if (minStack.Count == 0) {             return -1;         }         return minStack.Peek();     } }  class GfG {     static void Main() {         SpecialStack stack = new SpecialStack();                  stack.Push(18);         stack.Push(19);         stack.Push(29);         stack.Push(15);         stack.Push(16);          Console.WriteLine(stack.GetMin());     } }

JavaScript

class specialStack {     constructor() {         this.s = [];         this.minStack = [];     }      push(x) {         this.s.push(x);         // If the minStack is empty or the new element is smaller than          // the top of minStack, push it onto minStack         if (this.minStack.length === 0 || x <= this.minStack[this.minStack.length - 1]) {             this.minStack.push(x);         } else {             // Otherwise, push the top element of minStack              // again to keep the minimum unchanged             this.minStack.push(this.minStack[this.minStack.length - 1]);         }     }      // Pop the top element from the stack     pop() {         if (this.s.length === 0) {             return -1;         }         // Pop from both stacks         const poppedElement = this.s.pop();         this.minStack.pop();         return poppedElement;     }      // Return the top element of the stack without removing it     peek() {         if (this.s.length === 0) {             return -1;         }         return this.s[this.s.length - 1];     }      // Check if the stack is empty     isEmpty() {         return this.s.length === 0;     }      // Get the minimum element in the stack     getMin() {         if (this.minStack.length === 0) {             return -1;         }         return this.minStack[this.minStack.length - 1];     } }  const stack = new specialStack();  stack.push(18); stack.push(19); stack.push(29); stack.push(15); stack.push(16);  console.log(stack.getMin());

Output

Time Complexity:

For insert operation: O(1) (As insertion 'push' in a stack takes constant time)
For delete operation: O(1) (As deletion 'pop' in a stack takes constant time)
For 'Get Min' operation: O(1) (As we have used an auxiliary stack which has it's top as the minimum element)

Auxiliary Space: O(n)

Using a Pair in Stack - O(1) Time and O(n) Space

This approach uses a stack where each element is stored as a pair: the element itself and the minimum value up to that point. When an element is pushed, the minimum is updated. The getMin() function directly accesses the minimum value from the top of the stack in constant time, ensuring that both push(), pop(), and getMin() operations are O(1). This approach efficiently tracks the minimum value without needing to traverse the stack.

C++

// C++ program to implement a stack that supports // all operations in O(1) time and O(n) extra space.  #include <iostream> #include <stack> using namespace std;  // A user defined stack that supports getMin() in // addition to push(), pop() and peek() class SpecialStack { private:     stack<pair<int, int> > s;  public:     SpecialStack() {              }          // Add an element to the top of Stack     void push(int x) {         int newMin = s.empty() ? x : min(x, s.top().second);          // we push the pair of given element and newMin into stack         s.push({ x, newMin });     }          // Remove the top element from the Stack     void pop() {         if (!s.empty()) {             s.pop();         }     }          // Returns top element of the Stack     int peek() {         if (s.empty()) {             return -1;         }          int top = s.top().first;         return top;     }          // Finds minimum element of Stack     int getMin() {         if (s.empty()) {             return -1;         }                  int mn = s.top().second;         return mn;     } };  int main() {     SpecialStack ss;          // Function calls     ss.push(2);     ss.push(3);     cout << ss.peek() << " ";     ss.pop();     cout << ss.getMin() << " ";     ss.push(1);     cout << ss.getMin() << " "; }

Java

// Java program to implement a stack that supports // all operations in O(1) time and O(n) extra space.  import java.util.Stack;  class SpecialStack {     private Stack<int[]> s;      public SpecialStack() {         s = new Stack<>();     }      // Add an element to the top of Stack     public void push(int x) {         int newMin = s.isEmpty() ? x : Math.min(x, s.peek()[1]);         s.push(new int[]{x, newMin});     }      // Remove the top element from the Stack     public void pop() {         if (!s.isEmpty()) {             s.pop();         }     }      // Returns top element of the Stack     public int peek() {         return s.isEmpty() ? -1 : s.peek()[0];     }      // Finds minimum element of Stack     public int getMin() {         return s.isEmpty() ? -1 : s.peek()[1];     }      public static void main(String[] args) {         SpecialStack ss = new SpecialStack();          // Function calls         ss.push(2);         ss.push(3);         System.out.print(ss.peek() + " ");         ss.pop();         System.out.print(ss.getMin() + " ");         ss.push(1);         System.out.print(ss.getMin() + " ");     } }

Python

# Python program to implement a stack that supports # all operations in O(1) time and O(n) extra space.  class SpecialStack:     def __init__(self):         self.s = []      # Add an element to the top of Stack     def push(self, x):         newMin = x if not self.s else min(x, self.s[-1][1])         self.s.append((x, newMin))      # Remove the top element from the Stack     def pop(self):         if self.s:             self.s.pop()      # Returns top element of the Stack     def peek(self):         return -1 if not self.s else self.s[-1][0]      # Finds minimum element of Stack     def getMin(self):         return -1 if not self.s else self.s[-1][1]  if __name__ == "__main__":     ss = SpecialStack()     # Function calls     ss.push(2)     ss.push(3)     print(ss.peek(), end=" ")     ss.pop()     print(ss.getMin(), end=" ")     ss.push(1)     print(ss.getMin(), end=" ")

C#

// C# program to implement a stack that supports // all operations in O(1) time and O(n) extra space.  using System; using System.Collections.Generic;  class SpecialStack {     private Stack<(int, int)> s;      public SpecialStack() {         s = new Stack<(int, int)>();     }      // Add an element to the top of Stack     public void Push(int x) {         int newMin = s.Count == 0 ? x : Math.Min(x, s.Peek().Item2);         s.Push((x, newMin));     }      // Remove the top element from the Stack     public void Pop() {         if (s.Count > 0) {             s.Pop();         }     }      // Returns top element of the Stack     public int Peek() {         return s.Count == 0 ? -1 : s.Peek().Item1;     }      // Finds minimum element of Stack     public int GetMin() {         return s.Count == 0 ? -1 : s.Peek().Item2;     }      public static void Main() {         SpecialStack ss = new SpecialStack();          // Function calls         ss.Push(2);         ss.Push(3);         Console.Write(ss.Peek() + " ");         ss.Pop();         Console.Write(ss.GetMin() + " ");         ss.Push(1);         Console.Write(ss.GetMin() + " ");     } }

JavaScript

// JavaScript program to implement a stack that supports // all operations in O(1) time and O(n) extra space.  class SpecialStack {     constructor() {         this.s = [];     }      // Add an element to the top of Stack     push(x) {         let newMin = this.s.length === 0 ? x :                      Math.min(x, this.s[this.s.length - 1][1]);         this.s.push([x, newMin]);     }      // Remove the top element from the Stack     pop() {         if (this.s.length > 0) {             this.s.pop();         }     }      // Returns top element of the Stack     peek() {         return this.s.length === 0 ? -1 : this.s[this.s.length - 1][0];     }      // Finds minimum element of Stack     getMin() {         return this.s.length === 0 ? -1 : this.s[this.s.length - 1][1];     } }  // Driver Code const ss = new SpecialStack(); ss.push(2); ss.push(3); console.log(ss.peek() + " "); ss.pop(); console.log(ss.getMin() + " "); ss.push(1); console.log(ss.getMin() + " ");

Output

-4 0 -4 -1

Without Extra Space- O(1) Time and O(1) Space

The idea is to use a variable minEle to track the minimum element in the stack. Instead of storing the actual value of minEle in the stack, we store a modified value when pushing an element smaller than minEle. This allows retrieving the previous minimum in O(1) time and space.

Operations

Push(x)
- If the stack is empty, push x and set minEle = x.
- If x >= minEle, push x normally.
- If x < minEle, push 2*x - minEle and update minEle = x (this encodes the previous min).
Pop()
- Remove the top element.
- If the removed element is >= minEle, no change in minEle.
- If the removed element is < minEle, update minEle = 2*minEle - top (decoding the previous min).
Peek()
- Returns minEle if the top is modified (encoded) or top otherwise.
getMin()
- Returns minEle, the current minimum in O(1) time.

C++

// C++ program to implement a stack that supports // all operations in O(1) time and O(1) extra space.  #include <iostream> #include <stack> using namespace std;  // A user defined stack that supports getMin() in // addition to push(), pop() and peek() class SpecialStack {   private:     stack<int> s;     int minEle;        public:     SpecialStack() {         minEle = -1;     }          // Add an element to the top of Stack     void push(int x) {         if (s.empty()) {             minEle = x;             s.push(x);         }          // If new number is less than minEle         else if (x < minEle) {             s.push(2 * x - minEle);             minEle = x;         }          else {             s.push(x);         }     }          // Remove the top element from the Stack     void pop() {         if (s.empty()) {             return ;         }                  int top = s.top();         s.pop();                  // Minimum will change, if the minimum element         // of the stack is being removed.         if (top < minEle) {             minEle = 2 * minEle - top;         }     }          // Returns top element of the Stack     int peek() {         if (s.empty()) {             return -1;         }          int top = s.top();          // If minEle > top means minEle stores value of top.         return (minEle > top) ? minEle : top;     }          // Finds minimum element of Stack     int getMin() {         if (s.empty())             return -1;          // variable minEle stores the minimum element         // in the stack.         return minEle;     } };  int main() {     SpecialStack ss;          // Function calls     ss.push(2);     ss.push(3);     cout << ss.peek() << " ";     ss.pop();     cout << ss.getMin() << " ";     ss.push(1);     cout << ss.getMin() << " "; }

Java

// Java program to implement a stack that supports // all operations in O(1) time and O(1) extra space.  import java.util.Stack;  class SpecialStack {     private Stack<Integer> s;     private int minEle;      public SpecialStack() {         s = new Stack<>();         minEle = -1;     }      // Add an element to the top of Stack     public void push(int x) {         if (s.isEmpty()) {             minEle = x;             s.push(x);         }         // If new number is less than minEle         else if (x < minEle) {             s.push(2 * x - minEle);             minEle = x;         } else {             s.push(x);         }     }      // Remove the top element from the Stack     public void pop() {         if (s.isEmpty()) {             return;         }          int top = s.pop();          // Minimum will change, if the minimum element         // of the stack is being removed.         if (top < minEle) {             minEle = 2 * minEle - top;         }     }      // Returns top element of the Stack     public int peek() {         if (s.isEmpty()) {             return -1;         }          int top = s.peek();          // If minEle > top means minEle stores value of top.         return (minEle > top) ? minEle : top;     }      // Finds minimum element of Stack     public int getMin() {         if (s.isEmpty()) {             return -1;         }          // variable minEle stores the minimum element         // in the stack.         return minEle;     }      public static void main(String[] args) {         SpecialStack ss = new SpecialStack();          // Function calls         ss.push(2);         ss.push(3);         System.out.print(ss.peek() + " ");         ss.pop();         System.out.print(ss.getMin() + " ");         ss.push(1);         System.out.print(ss.getMin() + " ");     } }

Python

# Python program to implement a stack that supports # all operations in O(1) time and O(1) extra space.  class SpecialStack:     def __init__(self):         self.s = []         self.minEle = -1      # Add an element to the top of Stack     def push(self, x):         if not self.s:             self.minEle = x             self.s.append(x)         # If new number is less than minEle         elif x < self.minEle:             self.s.append(2 * x - self.minEle)             self.minEle = x         else:             self.s.append(x)      # Remove the top element from the Stack     def pop(self):         if not self.s:             return          top = self.s.pop()          # Minimum will change, if the minimum element         # of the stack is being removed.         if top < self.minEle:             self.minEle = 2 * self.minEle - top      # Returns top element of Stack     def peek(self):         if not self.s:             return -1          top = self.s[-1]          # If minEle > top means minEle stores value of top.         return self.minEle if self.minEle > top else top      # Finds minimum element of Stack     def getMin(self):         if not self.s:             return -1          # variable minEle stores the minimum element         # in the stack.         return self.minEle  if __name__ == '__main__':     ss = SpecialStack()          # Function calls     ss.push(2)     ss.push(3)     print(ss.peek(), end=" ")     ss.pop()     print(ss.getMin(), end=" ")     ss.push(1)     print(ss.getMin(), end=" ")

C#

// C# program to implement a stack that supports // all operations in O(1) time and O(1) extra space.  using System; using System.Collections.Generic;  class SpecialStack {     private Stack<int> s;     private int minEle;      public SpecialStack() {         s = new Stack<int>();         minEle = -1;     }      // Add an element to the top of Stack     public void Push(int x) {         if (s.Count == 0) {             minEle = x;             s.Push(x);         }         // If new number is less than minEle         else if (x < minEle) {             s.Push(2 * x - minEle);             minEle = x;         } else {             s.Push(x);         }     }      // Remove the top element from the Stack     public void Pop() {         if (s.Count == 0) {             return;         }          int top = s.Pop();          // Minimum will change, if the minimum element         // of the stack is being removed.         if (top < minEle) {             minEle = 2 * minEle - top;         }     }      // Returns top element of Stack     public int Peek() {         if (s.Count == 0) {             return -1;         }          int top = s.Peek();          // If minEle > top means minEle stores value of top.         return (minEle > top) ? minEle : top;     }      // Finds minimum element of Stack     public int GetMin() {         if (s.Count == 0) {             return -1;         }          // variable minEle stores the minimum element         // in the stack.         return minEle;     }      static void Main() {         SpecialStack ss = new SpecialStack();          // Function calls         ss.Push(2);         ss.Push(3);         Console.Write(ss.Peek() + " ");         ss.Pop();         Console.Write(ss.GetMin() + " ");         ss.Push(1);         Console.Write(ss.GetMin() + " ");     } }

JavaScript

// JavaScript program to implement a stack that supports // all operations in O(1) time and O(1) extra space.  class SpecialStack {     constructor() {         this.s = [];         this.minEle = -1;     }      // Add an element to the top of Stack     push(x) {         if (this.s.length === 0) {             this.minEle = x;             this.s.push(x);         }         // If new number is less than minEle         else if (x < this.minEle) {             this.s.push(2 * x - this.minEle);             this.minEle = x;         } else {             this.s.push(x);         }     }      // Remove the top element from the Stack     pop() {         if (this.s.length === 0) {             return;         }          let top = this.s.pop();          // Minimum will change, if the minimum element         // of the stack is being removed.         if (top < this.minEle) {             this.minEle = 2 * this.minEle - top;         }     }      // Returns top element of Stack     peek() {         if (this.s.length === 0) {             return -1;         }          let top = this.s[this.s.length - 1];          // If minEle > top means minEle stores value of top.         return this.minEle > top ? this.minEle : top;     }      // Finds minimum element of Stack     getMin() {         if (this.s.length === 0) {             return -1;         }          // variable minEle stores the minimum element         // in the stack.         return this.minEle;     } }  // Driver Code let ss = new SpecialStack(); ss.push(2); ss.push(3); console.log(ss.peek(), " "); ss.pop(); console.log(ss.getMin(), " "); ss.push(1); console.log(ss.getMin(), " ");

Output

3 2 1

How does this approach work?

When the element to be inserted is less than minEle, we insert "2x - minEle". The important thing to note is, that 2x - minEle will always be less than x (proved below), i.e., new minEle and while popping out this element we will see that something unusual has happened as the popped element is less than the minEle. So we will be updating minEle.

How 2*x - minEle is less than x in push()?
x < minEle which means x - minEle < 0
// Adding x on both sides
x - minEle + x < 0 + x
2*x - minEle < x
We can conclude 2*x - minEle < new minEle

While popping out, if we find the element(y) less than the current minEle, we find the new minEle = 2*minEle - y

How previous minimum element, prevMinEle is, 2*minEle - y
in pop() is y the popped element?
// We pushed y as 2x - prevMinEle. Here
// prevMinEle is minEle before y was inserted
y = 2*x - prevMinEle
// Value of minEle was made equal to x
minEle = x
new minEle = 2 * minEle - y
= 2*x - (2*x - prevMinEle)
= prevMinEle // This is what we wanted

Implement a stack using single queue

K

kartik

Improve

Article Tags :

Practice Tags :

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

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

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

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

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

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