Find maximum in a stack in O(1) time and O(1) extra space

Given a stack of integers. The task is to design a special stack such that maximum element can be found in O(1) time and O(1) extra space.

Examples:

Given Stack :
2
5
1
64   --> Maximum

So Output must be 64 when getMax() is called.

Below are the different functions designed to push and pop elements from the stack.
Push(x) : Inserts x at the top of stack.

If stack is empty, insert x into the stack and make maxEle equal to x.
If stack is not empty, compare x with maxEle. Two cases arise:
- If x is less than or equal to maxEle, simply insert x.
- If x is greater than maxEle, insert (2*x – maxEle) into the stack and make maxEle equal to x. For example, let previous maxEle was 3. Now we want to insert 4. We update maxEle as 4 and insert 2*4 – 3 = 5 into the stack.

Pop() : Removes an element from top of stack.

Remove element from top. Let the removed element be y. Two cases arise:
- If y is less than or equal to maxEle, the maximum element in the stack is still maxEle.
- If y is greater than maxEle, the maximum element now becomes (2*maxEle – y), so update (maxEle = 2*maxEle – y). This is where we retrieve previous maximum from current maximum and its value in stack. For example, let the element to be removed be 5 and maxEle be 4. We remove 5 and update maxEle as 2*4 – 5 = 3.

Important Points:

Stack doesn’t hold actual value of an element if it is maximum so far.
Actual maximum element is always stored in maxEle

Illustration

Push(x)

Number to be Inserted: 3, Stack is empty, so insert 3 into stack and maxEle = 3.
Number to be Inserted: 5, Stack is not empty, 5> maxEle, insert (2*5-3) into stack and maxEle = 5.
Number to be Inserted: 2, Stack is not empty, 2< maxEle, insert 2 into stack and maxEle = 5.
Number to be Inserted: 1, Stack is not empty, 1< maxEle, insert 1 into stack and maxEle = 5.

Pop()

Initially the maximum element maxEle in the stack is 5.
Number removed: 1, Since 1 is less than maxEle just pop 1. maxEle=5.
Number removed: 2, 2<maxEle, so number removed is 2 and maxEle is still equal to 5.
Number removed: 7, 7> maxEle, original number is maxEle which is 5 and new maxEle = 2*5 – 7 = 3.

C++

// C++ program to implement a stack that supports 
// getMaximum() in O(1) time and O(1) extra space. 
#include <bits/stdc++.h> 
using namespace std; 
  
// A user defined stack that supports getMax() in 
// addition to push() and pop() 
struct MyStack { 
    stack<int> s; 
    int maxEle; 
  
    // Prints maximum element of MyStack 
    void getMax() 
    { 
        if (s.empty()) 
            cout << "Stack is empty\n"; 
  
        // variable maxEle stores the maximum element 
        // in the stack. 
        else
            cout << "Maximum Element in the stack is: "
                 << maxEle << "\n"; 
    } 
  
    // Prints top element of MyStack 
    void peek() 
    { 
        if (s.empty()) { 
            cout << "Stack is empty "; 
            return; 
        } 
  
        int t = s.top(); // Top element. 
  
        cout << "Top Most Element is: "; 
  
        // If t < maxEle means maxEle stores 
        // value of t. 
        (t > maxEle) ? cout << maxEle : cout << t; 
    } 
  
    // Remove the top element from MyStack 
    void pop() 
    { 
        if (s.empty()) { 
            cout << "Stack is empty\n"; 
            return; 
        } 
  
        cout << "Top Most Element Removed: "; 
        int t = s.top(); 
        s.pop(); 
  
        // Maximum will change as the maximum element 
        // of the stack is being removed. 
        if (t > maxEle) { 
            cout << maxEle << "\n"; 
            maxEle = 2 * maxEle - t; 
        } 
  
        else
            cout << t << "\n"; 
    } 
  
    // Removes top element from MyStack 
    void push(int x) 
    { 
        // Insert new number into the stack 
        if (s.empty()) { 
            maxEle = x; 
            s.push(x); 
            cout << "Number Inserted: " << x << "\n"; 
            return; 
        } 
  
        // If new number is less than maxEle 
        if (x > maxEle) { 
            s.push(2 * x - maxEle); 
            maxEle = x; 
        } 
  
        else
            s.push(x); 
  
        cout << "Number Inserted: " << x << "\n"; 
    } 
}; 
  
// Driver Code 
int main() 
{ 
    MyStack s; 
    s.push(3); 
    s.push(5); 
    s.getMax(); 
    s.push(7); 
    s.push(19); 
    s.getMax(); 
    s.pop(); 
    s.getMax(); 
    s.pop(); 
    s.peek(); 
  
    return 0; 
} 

Java

// Java program to implement a stack that supports 
// getMaximum() in O(1) time and O(1) extra space. 
import java.util.*; 
  
class GFG  
{ 
  
// A user defined stack that supports getMax() in 
// addition to push() and pop() 
static class MyStack  
{ 
    Stack<Integer> s = new Stack<Integer>(); 
    int maxEle; 
  
    // Prints maximum element of MyStack 
    void getMax() 
    { 
        if (s.empty()) 
            System.out.print("Stack is empty\n"); 
  
        // variable maxEle stores the maximum element 
        // in the stack. 
        else
            System.out.print("Maximum Element in" +  
                        "the stack is: "+maxEle + "\n"); 
  
    } 
  
    // Prints top element of MyStack 
    void peek() 
    { 
        if (s.empty()) 
        { 
              
            System.out.print("Stack is empty "); 
            return; 
        } 
  
        int t = s.peek(); // Top element. 
  
        System.out.print("Top Most Element is: "); 
  
        // If t < maxEle means maxEle stores 
        // value of t. 
        if(t > maxEle) 
            System.out.print(maxEle); 
        else
            System.out.print(t); 
    } 
  
    // Remove the top element from MyStack 
    void pop() 
    { 
        if (s.empty())  
        { 
            System.out.print("Stack is empty\n"); 
            return; 
        } 
  
        System.out.print("Top Most Element Removed: "); 
        int t = s.peek(); 
        s.pop(); 
  
        // Maximum will change as the maximum element 
        // of the stack is being removed. 
        if (t > maxEle) 
        { 
            System.out.print(maxEle + "\n"); 
            maxEle = 2 * maxEle - t; 
        } 
  
        else
            System.out.print(t + "\n"); 
    } 
  
    // Removes top element from MyStack 
    void push(int x) 
    { 
        // Insert new number into the stack 
        if (s.empty())  
        { 
            maxEle = x; 
            s.push(x); 
            System.out.print("Number Inserted: " + x + "\n"); 
            return; 
        } 
  
        // If new number is less than maxEle 
        if (x > maxEle)  
        { 
            s.push(2 * x - maxEle); 
            maxEle = x; 
        } 
  
        else
            s.push(x); 
  
        System.out.print("Number Inserted: " + x + "\n"); 
    } 
}; 
  
// Driver Code 
public static void main(String[] args)  
{ 
    MyStack s = new MyStack(); 
    s.push(3); 
    s.push(5); 
    s.getMax(); 
    s.push(7); 
    s.push(19); 
    s.getMax(); 
    s.pop(); 
    s.getMax(); 
    s.pop(); 
    s.peek(); 
    } 
} 
  
/* This code contributed by PrinciRaj1992 */

Python 3

# Class to make a Node  
class Node: 
    #Constructor which assign argument to nade's value  
    def __init__(self, value): 
        self.value = value 
        self.next = None
    
    # This method returns the string representation of the object. 
    def __str__(self): 
        return "Node({})".format(self.value) 
      
    #  __repr__ is same as __str__ 
    __repr__ = __str__ 
    
  
class Stack: 
    # Stack Constructor initialise top of stack and counter. 
    def __init__(self): 
        self.top = None
        self.count = 0
        self.maximum = None
          
    #This method returns the string representation of the object (stack). 
    def __str__(self): 
        temp=self.top 
        out=[] 
        while temp: 
            out.append(str(temp.value)) 
            temp=temp.next
        out='\n'.join(out) 
        return ('Top {} \n\nStack :\n{}'.format(self.top,out)) 
          
    #  __repr__ is same as __str__ 
    __repr__=__str__ 
      
    #This method is used to get minimum element of stack 
    def getMax(self): 
        if self.top is None: 
            return "Stack is empty"
        else: 
            print("Maximum Element in the stack is: {}" .format(self.maximum)) 
  
   
  
    # Method to check if Stack is Empty or not 
    def isEmpty(self): 
        # If top equals to None then stack is empty  
        if self.top == None: 
            return True
        else: 
        # If top not equal to None then stack is empty  
            return False
  
    # This method returns length of stack        
    def __len__(self): 
        self.count = 0
        tempNode = self.top 
        while tempNode: 
            tempNode = tempNode.next
            self.count+=1
        return self.count 
  
    # This method returns top of stack        
    def peek(self): 
        if self.top is None: 
            print ("Stack is empty") 
        else:     
            if self.top.value > self.maximum: 
                print("Top Most Element is: {}" .format(self.maximum)) 
            else: 
                print("Top Most Element is: {}" .format(self.top.value)) 
  
    #This method is used to add node to stack 
    def push(self,value): 
        if self.top is None: 
            self.top = Node(value) 
            self.maximum = value 
              
        elif value > self.maximum : 
            temp = (2 * value) - self.maximum 
            new_node = Node(temp) 
            new_node.next = self.top 
            self.top = new_node 
            self.maximum = value 
        else: 
            new_node = Node(value) 
            new_node.next = self.top 
            self.top = new_node 
        print("Number Inserted: {}" .format(value)) 
    
    #This method is used to pop top of stack 
    def pop(self): 
        if self.top is None: 
            print( "Stack is empty") 
        else: 
            removedNode = self.top.value 
            self.top = self.top.next
            if removedNode > self.maximum: 
                print ("Top Most Element Removed :{} " .format(self.maximum)) 
                self.maximum = ( ( 2 * self.maximum ) - removedNode ) 
            else: 
                print ("Top Most Element Removed : {}" .format(removedNode)) 
  
                  
              
      
 # Driver program to test above class   
stack = Stack()  
  
stack.push(3) 
stack.push(5)  
stack.getMax() 
stack.push(7) 
stack.push(19) 
stack.getMax()      
stack.pop() 
stack.getMax() 
stack.pop()  
stack.peek() 
  
# This code is contributed by Blinkii 

C#

// C# program to implement a stack that supports  
// getMaximum() in O(1) time and O(1) extra space.  
using System;  
using System.Collections.Generic; 
  
class GFG  
{  
  
// A user defined stack that supports getMax() in  
// addition to push() and pop()  
public class MyStack  
{  
    public Stack<int> s = new Stack<int>();  
    public int maxEle;  
  
    // Prints maximum element of MyStack  
    public void getMax()  
    {  
        if (s.Count == 0)  
            Console.Write("Stack is empty\n");  
  
        // variable maxEle stores the maximum element  
        // in the stack.  
        else
            Console.Write("Maximum Element in" +  
                        "the stack is: "+maxEle + "\n");  
  
    }  
  
    // Prints top element of MyStack  
    public void peek()  
    {  
        if (s.Count == 0)  
        {  
              
            Console.Write("Stack is empty ");  
            return;  
        }  
  
        int t = s.Peek(); // Top element.  
  
        Console.Write("Top Most Element is: ");  
  
        // If t < maxEle means maxEle stores  
        // value of t.  
        if(t > maxEle)  
            Console.Write(maxEle);  
        else
            Console.Write(t);  
    }  
  
    // Remove the top element from MyStack  
    public void pop()  
    {  
        if (s.Count == 0)  
        {  
            Console.Write("Stack is empty\n");  
            return;  
        }  
  
        Console.Write("Top Most Element Removed: ");  
        int t = s.Peek();  
        s.Pop();  
  
        // Maximum will change as the maximum element  
        // of the stack is being removed.  
        if (t > maxEle)  
        {  
            Console.Write(maxEle + "\n");  
            maxEle = 2 * maxEle - t;  
        }  
  
        else
            Console.Write(t + "\n");  
    }  
  
    // Removes top element from MyStack  
    public void push(int x)  
    {  
        // Insert new number into the stack  
        if (s.Count == 0)  
        {  
            maxEle = x;  
            s.Push(x);  
            Console.Write("Number Inserted: " + x + "\n");  
            return;  
        }  
  
        // If new number is less than maxEle  
        if (x > maxEle)  
        {  
            s.Push(2 * x - maxEle);  
            maxEle = x;  
        }  
  
        else
            s.Push(x);  
  
        Console.Write("Number Inserted: " + x + "\n");  
    }  
};  
  
// Driver Code  
public static void Main(String[] args)  
{  
    MyStack s = new MyStack();  
    s.push(3);  
    s.push(5);  
    s.getMax();  
    s.push(7);  
    s.push(19);  
    s.getMax();  
    s.pop();  
    s.getMax();  
    s.pop();  
    s.peek();  
}  
}  
  
// This code is contributed by Princi Singh 

Output:

Number Inserted: 3
Number Inserted: 5
Maximum Element in the stack is: 5
Number Inserted: 7
Number Inserted: 19
Maximum Element in the stack is: 19
Top Most Element Removed: 19
Maximum Element in the stack is: 7
Top Most Element Removed: 7
Top Most Element is: 5

My Personal Notes

Suggest a Topic

C++

Java

Python 3

C#

Recommended Posts: