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.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

My Personal Notes arrow_drop_up