# Design a stack which can give maximum frequency element

Given **N** elements and the task is to implement a stack which removes and returns the maximum frequency element on every pop operation. If there’s a tie in the frequency then the topmost highest frequency element will be returned.

**Examples:**

Input:

push(4) 8

push(6) 6

push(7) 7

push(6) 6

push(8); 4

Output:

pop() -> returns 6, as 6 is the most frequent (frequency of 6 = 2 ).

pop() -> returns 8 (6 also has the highest frequency but it is not the topmost)

**Approach:** Maintaining two HashMap, one is frequency HashMap which maps elements to their frequencies and other is setMap which maps all the element with same frequency in one group (Stack).

FrequencyStack has 2 functions:

**push(int x):**map the element (x) with frequency HashMap and update the maxfreq variable ( i.e. holds the maximum frequency till now ).**setMap**maintains a stack which contains all the elements with same frequency.**pop():**First get the maxfreq element from setMap and then decrement the frequency of the popped element. After popping, if the stack becomes empty then decrement the maxfreq.

Below is the implementation of the above approach:

## C++

// C++ implementation of the approach

#include

using namespace std;

// freqMap is to map element to its frequency

map

// setMap is to map frequency to the

// element list with this frequency

map

// Variable which stores maximum frequency

// of the stack element

int maxfreq = 0;

// Function to insert x in the stack

void push(int x)

{

// Frequency of x

int freq = freqMap[x] + 1;

// Mapping of x with its frequency

freqMap[x]= freq;

// Update maxfreq variable

if (freq > maxfreq)

maxfreq = freq;

// Map element to its frequency list

// If given frequency list doesn’t exist

// make a new list of the required frequency

setMap[freq].push(x);

}

// Function to remove maximum frequency element

int pop()

{

// Remove element from setMap

// from maximum frequency list

int top = setMap[maxfreq].top();

setMap[maxfreq].pop();

// Decrement the frequency of the popped element

freqMap[top]–;

// If whole list is poppped

// then decrement the maxfreq

if (setMap[maxfreq].size() == 0)

maxfreq–;

return top;

}

// Driver code

int main()

{

// Push elements to the stack

push(4);

push(6);

push(7);

push(6);

push(8);

// Pop elements

cout << (pop()) << "\n" ;
cout << (pop());
return 0;
}
// This code is contributed by Arnab Kundu
[tabby title="Java"]

`// Java implementation of the approach ` `import` `java.util.*; ` ` ` `public` `class` `freqStack { ` ` ` ` ` `// freqMap is to map element to its frequency ` ` ` `static` `Map<Integer, Integer> freqMap = ` `new` `HashMap<>(); ` ` ` ` ` `// setMap is to map frequency to the ` ` ` `// element list with this frequency ` ` ` `static` `Map<Integer, Stack<Integer> > setMap = ` `new` `HashMap<>(); ` ` ` ` ` `// Variable which stores maximum frequency ` ` ` `// of the stack element ` ` ` `static` `int` `maxfreq = ` `0` `; ` ` ` ` ` `// Function to insert x in the stack ` ` ` `public` `static` `void` `push(` `int` `x) ` ` ` `{ ` ` ` ` ` `// Frequency of x ` ` ` `int` `freq = freqMap.getOrDefault(x, ` `0` `) + ` `1` `; ` ` ` ` ` `// Mapping of x with its frequency ` ` ` `freqMap.put(x, freq); ` ` ` ` ` `// Update maxfreq variable ` ` ` `if` `(freq > maxfreq) ` ` ` `maxfreq = freq; ` ` ` ` ` `// Map element to its frequency list ` ` ` `// If given frequency list doesn't exist ` ` ` `// make a new list of the required frequency ` ` ` `setMap.computeIfAbsent(freq, z -> ` `new` `Stack()).push(x); ` ` ` `} ` ` ` ` ` `// Function to remove maximum frequency element ` ` ` `public` `static` `int` `pop() ` ` ` `{ ` ` ` ` ` `// Remove element from setMap ` ` ` `// from maximum frequency list ` ` ` `int` `top = setMap.get(maxfreq).pop(); ` ` ` ` ` `// Decrement the frequency of the popped element ` ` ` `freqMap.put(top, freqMap.get(top) - ` `1` `); ` ` ` ` ` `// If whole list is poppped ` ` ` `// then decrement the maxfreq ` ` ` `if` `(setMap.get(maxfreq).size() == ` `0` `) ` ` ` `maxfreq--; ` ` ` `return` `top; ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{ ` ` ` ` ` `// Push elements to the stack ` ` ` `push(` `4` `); ` ` ` `push(` `6` `); ` ` ` `push(` `7` `); ` ` ` `push(` `6` `); ` ` ` `push(` `8` `); ` ` ` ` ` `// Pop elements ` ` ` `System.out.println(pop()); ` ` ` `System.out.println(pop()); ` ` ` `} ` `} ` |

*chevron_right*

*filter_none*

**Output:**

6 8

## Recommended Posts:

- Design a stack with operations on middle element
- Maximum difference between frequency of two elements such that element having greater frequency is also greater
- Design a stack to retrieve original elements and return the minimum element in O(1) time and O(1) space
- Tracking current Maximum Element in a Stack
- Replace each element by the difference of the total size of the array and frequency of that element
- Find maximum in stack in O(1) without using additional stack
- Sudo Placement[1.3] | Stack Design
- Design a stack that supports getMin() in O(1) time and O(1) extra space
- Sliding Window Maximum (Maximum of all subarrays of size k) using stack in O(n) time
- Next Greater Frequency Element
- Design and Implement Special Stack Data Structure | Added Space Optimized Version
- Python | Element with largest frequency in list
- Find the element having different frequency than other array elements
- Frequency of each element of an array of small ranged values
- Cumulative frequency of count of each element in an unsorted array

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.