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

• Difficulty Level : Medium
• Last Updated : 24 Feb, 2022

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 greater 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`

## Javascript

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

Time Complexity: O(1)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up