Related Articles
Find maximum in a stack in O(1) time and O(1) extra space
• Difficulty Level : Medium
• Last Updated : 07 Jun, 2019

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 ``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 s = ``new` `Stack();``    ``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
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up