# 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 ` `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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.