Next Greater Frequency Element
Last Updated :
11 Feb, 2025
Given an array, for each element find the value of the nearest element to the right which is having a frequency greater than that of the current element. If there does not exist an answer for a position, then make the value ‘-1’.
Examples:
Input : a[] = [1, 1, 2, 3, 4, 2, 1]
Output : [-1, -1, 1, 2, 2, 1, -1]
Explanation:
Given array a[] = [1, 1, 2, 3, 4, 2, 1]
Frequency of each element is: 3, 3, 2, 1, 1, 2, 3
Lets calls Next Greater Frequency element as NGF
1. For element a[0] = 1 which has a frequency = 3,
As it has frequency of 3 and no other next element
has frequency more than 3 so '-1'
2. For element a[1] = 1 it will be -1 same logic
like a[0]
3. For element a[2] = 2 which has frequency = 2,
NGF element is 1 at position = 6 with frequency
of 3 > 2
4. For element a[3] = 3 which has frequency = 1,
NGF element is 2 at position = 5 with frequency
of 2 > 1
5. For element a[4] = 4 which has frequency = 1,
NGF element is 2 at position = 5 with frequency
of 2 > 1
6. For element a[5] = 2 which has frequency = 2,
NGF element is 1 at position = 6 with frequency
of 3 > 2
7. For element a[6] = 1 there is no element to its
right, hence -1
Input : a[] = [1, 1, 1, 2, 2, 2, 2, 11, 3, 3]
Output : [2, 2, 2, -1, -1, -1, -1, 3, -1, -1]
Naive approach:
A simple hashing technique is to use values as the index is being used to store the frequency of each element. Create a list suppose to store the frequency of each number in the array. (Single traversal is required). Now use two loops.
The outer loop picks all the elements one by one.
The inner loop looks for the first element whose frequency is greater than the frequency of the current element.
If a greater frequency element is found then that element is printed, otherwise -1 is printed.
Time complexity: O(n*n)
Efficient approach:
We can use hashing and stack data structure to efficiently solve for many cases. A simple hashing technique is to use values as index and frequency of each element as value. We use the stack data structure to store the position of elements in the array.
- Create a list to use values as index to store frequency of each element.
- Push the position of first element to stack.
- Pick rest of the position of elements one by one and follow following steps in loop.
- Mark the position of current element as ‘i’ .
- If the frequency of the element which is pointed by the top of stack is greater than frequency of the current element, push the current position i to the stack
- If the frequency of the element which is pointed by the top of stack is less than frequency of the current element and the stack is not empty then follow these steps:
- continue popping the stack
- if the condition in step c fails then push the current position i to the stack
- After the loop in step 3 is over, pop all the elements from stack and print -1 as next greater frequency element for them does not exist.
Below is the implementation of the above problem.
C++
// C++ program of Next Greater Frequency Element
#include <iostream>
#include <stack>
#include <stdio.h>
using namespace std;
/*NFG function to find the next greater frequency
element for each element in the array*/
void NFG(int a[], int n, int freq[])
{
// stack data structure to store the position
// of array element
stack<int> s;
s.push(0);
// res to store the value of next greater
// frequency element for each element
int res[n] = { 0 };
for (int i = 1; i < n; i++)
{
/* If the frequency of the element which is
pointed by the top of stack is greater
than frequency of the current element
then push the current position i in stack*/
if (freq[a[s.top()]] > freq[a[i]])
s.push(i);
else {
/*If the frequency of the element which
is pointed by the top of stack is less
than frequency of the current element, then
pop the stack and continuing popping until
the above condition is true while the stack
is not empty*/
while ( !s.empty()
&& freq[a[s.top()]] < freq[a[i]])
{
res[s.top()] = a[i];
s.pop();
}
// now push the current element
s.push(i);
}
}
while (!s.empty()) {
res[s.top()] = -1;
s.pop();
}
for (int i = 0; i < n; i++)
{
// Print the res list containing next
// greater frequency element
cout << res[i] << " ";
}
}
// Driver code
int main()
{
int a[] = { 1, 1, 2, 3, 4, 2, 1 };
int len = 7;
int max = INT16_MIN;
for (int i = 0; i < len; i++)
{
// Getting the max element of the array
if (a[i] > max) {
max = a[i];
}
}
int freq[max + 1] = { 0 };
// Calculating frequency of each element
for (int i = 0; i < len; i++)
{
freq[a[i]]++;
}
// Function call
NFG(a, len, freq);
return 0;
}
// Java program of Next Greater Frequency Element
import java.util.*;
class GFG {
/*NFG function to find the next greater frequency
element for each element in the array*/
static void NFG(int a[], int n, int freq[])
{
// stack data structure to store the position
// of array element
Stack<Integer> s = new Stack<Integer>();
s.push(0);
// res to store the value of next greater
// frequency element for each element
int res[] = new int[n];
for (int i = 0; i < n; i++)
res[i] = 0;
for (int i = 1; i < n; i++)
{
/* If the frequency of the element which is
pointed by the top of stack is greater
than frequency of the current element
then push the current position i in stack*/
if (freq[a[s.peek()]] > freq[a[i]])
s.push(i);
else
{
/*If the frequency of the element which
is pointed by the top of stack is less
than frequency of the current element, then
pop the stack and continuing popping until
the above condition is true while the stack
is not empty*/
while (freq[a[s.peek()]] < freq[a[i]]
&& s.size() > 0)
{
res[s.peek()] = a[i];
s.pop();
}
// now push the current element
s.push(i);
}
}
while (s.size() > 0)
{
res[s.peek()] = -1;
s.pop();
}
for (int i = 0; i < n; i++)
{
// Print the res list containing next
// greater frequency element
System.out.print(res[i] + " ");
}
}
// Driver code
public static void main(String args[])
{
int a[] = { 1, 1, 2, 3, 4, 2, 1 };
int len = 7;
int max = Integer.MIN_VALUE;
for (int i = 0; i < len; i++)
{
// Getting the max element of the array
if (a[i] > max)
{
max = a[i];
}
}
int freq[] = new int[max + 1];
for (int i = 0; i < max + 1; i++)
freq[i] = 0;
// Calculating frequency of each element
for (int i = 0; i < len; i++)
{
freq[a[i]]++;
}
// Function call
NFG(a, len, freq);
}
}
// This code is contributed by Arnab Kundu
def NFG(a, n):
if n <= 0:
print("List empty")
return []
# stack data structure to store the position
# of array element
stack = [0] * n
# freq is a dictionary which maintains the
# frequency of each element
freq = {}
for i in a:
freq[i] = 0
for i in a:
freq[i] += 1
# res to store the value of the next greater
# frequency element for each element
res = [0] * n
# initialize top of stack to -1
top = -1
# push the first position of the array onto the stack
top += 1
stack[top] = 0
# now iterate for the rest of the elements
for i in range(1, n):
if freq[a[stack[top]]] > freq[a[i]]:
top += 1
stack[top] = i
else:
while top > -1 and freq[a[stack[top]]] < freq[a[i]]:
res[stack[top]] = a[i]
top -= 1
top += 1
stack[top] = i
# After iterating over the loop, the remaining
# positions of elements in the stack do not have the
# next greater element, so print -1 for them
while top > -1:
res[stack[top]] = -1
top -= 1
# return the res list containing the next
# greater frequency element
return res
# Driver Code
print(NFG([1, 1, 2, 3, 4, 2, 1], 7))
// C# program of Next Greater Frequency Element
using System;
using System.Collections;
class GFG {
/*NFG function to find the
next greater frequency
element for each element
in the array*/
static void NFG(int[] a, int n, int[] freq)
{
// stack data structure to store
// the position of array element
Stack s = new Stack();
s.Push(0);
// res to store the value of next greater
// frequency element for each element
int[] res = new int[n];
for (int i = 0; i < n; i++)
res[i] = 0;
for (int i = 1; i < n; i++)
{
/* If the frequency of the element which is
pointed by the top of stack is greater
than frequency of the current element
then Push the current position i in stack*/
if (freq[a[(int)s.Peek()]] > freq[a[i]])
s.Push(i);
else
{
/*If the frequency of the element which
is pointed by the top of stack is less
than frequency of the current element, then
Pop the stack and continuing Popping until
the above condition is true while the stack
is not empty*/
while (freq[a[(int)(int)s.Peek()]]
< freq[a[i]]
&& s.Count > 0)
{
res[(int)s.Peek()] = a[i];
s.Pop();
}
// now Push the current element
s.Push(i);
}
}
while (s.Count > 0)
{
res[(int)s.Peek()] = -1;
s.Pop();
}
for (int i = 0; i < n; i++)
{
// Print the res list containing next
// greater frequency element
Console.Write(res[i] + " ");
}
}
// Driver code
public static void Main(String[] args)
{
int[] a = { 1, 1, 2, 3, 4, 2, 1 };
int len = 7;
int max = int.MinValue;
for (int i = 0; i < len; i++)
{
// Getting the max element of the array
if (a[i] > max)
{
max = a[i];
}
}
int[] freq = new int[max + 1];
for (int i = 0; i < max + 1; i++)
freq[i] = 0;
// Calculating frequency of each element
for (int i = 0; i < len; i++)
{
freq[a[i]]++;
}
NFG(a, len, freq);
}
}
// This code is contributed by Arnab Kundu
// JavaScript program to find the Next Greater Frequency Element
// Function to find the next greater frequency element for each element in the array
function NFG(a, n, freq) {
let s = []; // Stack to store positions of array elements
let res = new Array(n).fill(0); // Result array to store next greater frequency elements
s.push(0); // Push the first element's index
for (let i = 1; i < n; i++) {
// If frequency of element at stack top is greater, push current index
if (freq[a[s[s.length - 1]]] > freq[a[i]]) {
s.push(i);
} else {
// Pop stack while frequency of current element is greater
while (s.length > 0 && freq[a[s[s.length - 1]]] < freq[a[i]]) {
res[s.pop()] = a[i];
}
s.push(i); // Push the current index
}
}
// For remaining elements in stack, no greater frequency element exists
while (s.length > 0) {
res[s.pop()] = -1;
}
console.log("Next Greater Frequency Elements:", res);
}
// Input array
let a = [1, 1, 2, 3, 4, 2, 1];
let len = a.length;
// Find max element in the array
let max = Math.max(...a);
// Frequency array to store occurrences of each element
let freq = new Array(max + 1).fill(0);
for (let i = 0; i < len; i++) {
freq[a[i]]++;
}
// Function call
NFG(a, len, freq);
Time complexity: O(n)
Auxiliary space: O(n)
The Next To Brute Force/Brute Force:
The Approach:
The approach is simple we just store the frequency of all element in map then push all element in reverse order to the stack as we know the nature of stack is LIFO so then we traverse over vector and find the next greater for every element in vector using stack ans map.
C++
#include <iostream>
#include<bits/stdc++.h>
using namespace std;
int main() {
vector<int>v{1, 1, 2, 3, 4, 2, 1};
int n=v.size();
map<int,int>mp;
stack<int>s;
for(auto it:v){
mp[it]++;
}
for(int i=n-1;i>=0;i--)s.push(v[i]);
for(int i=0;i<n;i++){
int x=mp[v[i]];
bool flag=1;
stack<int>ss(s);
while(!ss.empty()){
if(mp[ss.top()]>x){
cout<<v[i]<<" --> "<<ss.top()<<endl;
flag=0;
break;
}
ss.pop();
}
if(flag)cout<<v[i]<<" --> "<<-1<<endl;
s.pop();
}
return 0;
}
import java.util.*;
class Main {
public static void main(String[] args)
{
List<Integer> v
= Arrays.asList(1, 1, 2, 3, 4, 2, 1);
int n = v.size();
Map<Integer, Integer> mp = new HashMap<>();
Stack<Integer> s = new Stack<>();
for (int i : v) {
mp.put(i, mp.getOrDefault(i, 0) + 1);
}
for (int i = n - 1; i >= 0; i--)
s.push(v.get(i));
for (int i = 0; i < n; i++) {
int x = mp.get(v.get(i));
boolean flag = true;
Stack<Integer> ss = (Stack<Integer>)s.clone();
while (!ss.empty()) {
if (mp.get(ss.peek()) > x) {
System.out.println(v.get(i) + " --> "
+ ss.peek());
flag = false;
break;
}
ss.pop();
}
if (flag)
System.out.println(v.get(i) + " --> " + -1);
s.pop();
}
}
}
// This code is contributed by divyansh2212
from collections import defaultdict
def main():
v = [1, 1, 2, 3, 4, 2, 1]
n = len(v)
mp = defaultdict(int)
s = []
for x in v:
mp[x] += 1
for i in range(n-1, -1, -1):
s.append(v[i])
for i in range(n):
x = mp[v[i]]
flag = True
ss = list(s)
while ss:
if mp[ss[-1]] > x:
print(v[i], "-->", ss[-1])
flag = False
break
ss.pop()
if flag:
print(v[i], "-->", -1)
s.pop()
if __name__ == "__main__":
main()
// C# program for the above approach
using System;
using System.Collections;
using System.Collections.Generic;
class GFG {
static void Main() {
int[] v = {1, 1, 2, 3, 4, 2, 1};
int n=v.Length;
Dictionary<int, int> mp = new Dictionary<int, int>();
Stack s = new Stack();
for(int i = 0; i < v.Length; i++){
if(mp.ContainsKey(v[i]) == true){
mp[v[i]] = mp[v[i]] + 1;
}
else{
mp.Add(v[i], 1);
}
}
for(int i=n-1;i>=0;i--){
s.Push(v[i]);
}
for(int i=0;i<n;i++){
int x = mp[v[i]];
int flag=1;
Stack ss = (Stack)s.Clone();
while(ss.Count > 0){
int val = (int)ss.Peek();
if(mp[val]>x){
Console.WriteLine(v[i] + " --> " + val);
flag=0;
break;
}
ss.Pop();
}
if(flag != 0){
Console.WriteLine(v[i] + " --> -1");
}
s.Pop();
}
}
}
// The code is contributed by Arushi Jindal.
let v = [1, 1, 2, 3, 4, 2, 1];
let n = v.length;
let mp = new Map();
let s = [];
// Calculate frequency of each element
for (let i = 0; i < n; i++) {
mp.set(v[i], (mp.get(v[i]) || 0) + 1);
}
// Push elements in reverse order into stack
for (let i = n - 1; i >= 0; i--) {
s.push(v[i]);
}
// Iterate through the array to find next greater frequency element
for (let i = 0; i < n; i++) {
let x = mp.get(v[i]);
let flag = true;
let ss = [...s]; // Create a copy of the stack
while (ss.length > 0) {
if (mp.get(ss[ss.length - 1]) > x) {
console.log(v[i] + " --> " + ss[ss.length - 1]);
flag = false;
break;
}
ss.pop();
}
if (flag) console.log(v[i] + " --> " + -1);
s.pop();
}
Output1 --> -1
1 --> -1
2 --> 1
3 --> 2
4 --> 2
2 --> 1
1 --> -1
Time complexity: O(n^2),for worst case.
Auxiliary space: O(2n),for map and stack.
Space Efficient Approach: using a hash map instead of a list as mentioned in the above approach.
Steps:
- Create a class pair to store pair<int, int> with pair<element, frequency>.
- Create a hash map with pair as generics to store keys as the element and values as the frequency of every element.
- Iterate the array and save the element and its frequency in the hashmap.
- Create a res array that stores the resultant array.
- Initially make res[n-1] = -1 and push the element in the end along with its frequency into the stack.
- Iterate through the array in reverse order.
- If the frequency of the element which is pointed at the top of the stack is less than the frequency of the current element and the stack is not empty then pop.
- Continue till the loop fails.
- If the stack is empty, it means that there is no element with a higher frequency. So, place -1 as the next higher frequency element in the resultant array.
- If the stack is not empty, it means that the top of the stack has a higher frequency element. Put it in the resultant array as the next higher frequency.
- Push the current element along with its frequency.
Implementation:
C++
// C++ program of Next Greater Frequency Element
#include <bits/stdc++.h>
using namespace std;
stack<pair<int,int>> mystack;
map<int, int> mymap;
/*NFG function to find the next greater frequency
element for each element and for placing it in the
resultant array */
void NGF(int arr[], int res[], int n) {
// Initially store the frequencies of all elements
// in a hashmap
for(int i = 0; i < n; i++) {
mymap[arr[i]] += 1;
}
// Get the frequency of the last element
int curr_freq = mymap[arr[n-1]];
// push it to the stack
mystack.push({arr[n-1], curr_freq});
// place -1 as next greater freq for the last
// element as it does not have next greater.
res[n-1] = -1;
// iterate through array in reverse order
for(int i = n-2;i>=0;i--) {
curr_freq = mymap[arr[i]];
/* If the frequency of the element which is
pointed by the top of stack is greater
than frequency of the current element
then push the current position i in stack*/
while(mystack.size() > 0 && curr_freq >= mystack.top().second)
mystack.pop();
// If the stack is empty, place -1. If it is not empty
// then we will have next higher freq element at the top of the stack.
res[i] = (mystack.size() == 0) ? -1 : mystack.top().first;
// push the element at current position
mystack.push({arr[i], mymap[arr[i]]});
}
}
int main()
{
int arr[] = {1, 1, 1, 2, 2, 2, 2, 11, 3, 3};
int n = sizeof(arr) / sizeof(arr[0]);
int res[n];
NGF(arr, res, n);
cout << "[";
for(int i = 0; i < n - 1; i++)
{
cout << res[i] << ", ";
}
cout << res[n - 1] << "]";
return 0;
}
// This code is contributed by divyeshrabadiya07.
// Java program of Next Greater Frequency Element
import java.util.*;
class GFG {
Stack<Pair> mystack = new Stack<>();
HashMap<Integer,Integer> mymap = new HashMap<>();
class Pair{
int data;
int freq;
Pair(int data,int freq){
this.data = data;
this.freq = freq;
}
}
/*NFG function to find the next greater frequency
element for each element and for placing it in the
resultant array */
void NGF(int[] arr,int[] res) {
int n = arr.length;
//Initially store the frequencies of all elements
//in a hashmap
for(int i = 0;i<n;i++) {
if(mymap.containsKey(arr[i]))
mymap.put(arr[i], mymap.get(arr[i]) + 1);
else
mymap.put(arr[i], 1);
}
//Get the frequency of the last element
int curr_freq = mymap.get(arr[n-1]);
//push it to the stack
mystack.push(new Pair(arr[n-1],curr_freq));
//place -1 as next greater freq for the last
//element as it does not have next greater.
res[n-1] = -1;
//iterate through array in reverse order
for(int i = n-2;i>=0;i--) {
curr_freq = mymap.get(arr[i]);
/* If the frequency of the element which is
pointed by the top of stack is greater
than frequency of the current element
then push the current position i in stack*/
while(!mystack.isEmpty() && curr_freq >= mystack.peek().freq)
mystack.pop();
//If the stack is empty, place -1. If it is not empty
//then we will have next higher freq element at the top of the stack.
res[i] = (mystack.isEmpty()) ? -1 : mystack.peek().data;
//push the element at current position
mystack.push(new Pair(arr[i],mymap.get(arr[i])));
}
}
//Driver function
public static void main(String args[]) {
GFG obj = new GFG();
int[] arr = {1, 1, 1, 2, 2, 2, 2, 11, 3, 3};
int res[] = new int[arr.length];
obj.NGF(arr, res);
System.out.println(Arrays.toString(res));
}
}
//This method is contributed by Likhita AVL
# Python3 program of Next Greater Frequency Element
mystack = []
mymap = {}
"""NFG function to find the next greater frequency
element for each element and for placing it in the
resultant array """
def NGF(arr, res):
n = len(arr)
# Initially store the frequencies of all elements
# in a hashmap
for i in range(n):
if arr[i] in mymap:
mymap[arr[i]] += 1
else:
mymap[arr[i]] = 1
# Get the frequency of the last element
curr_freq = mymap[arr[n-1]]
# push it to the stack
mystack.append([arr[n-1],curr_freq])
# place -1 as next greater freq for the last
# element as it does not have next greater.
res[n-1] = -1
# iterate through array in reverse order
for i in range(n - 2, -1, -1):
curr_freq = mymap[arr[i]]
""" If the frequency of the element which is
pointed by the top of stack is greater
than frequency of the current element
then push the current position i in stack"""
while len(mystack) > 0 and curr_freq >= mystack[-1][1]:
mystack.pop()
# If the stack is empty, place -1. If it is not empty
# then we will have next higher freq element at the top of the stack.
if (len(mystack) == 0):
res[i] = -1
else:
res[i] = mystack[-1][0]
# push the element at current position
mystack.append([arr[i],mymap[arr[i]]])
arr = [1, 1, 1, 2, 2, 2, 2, 11, 3, 3]
res = [0]*(len(arr))
NGF(arr, res)
print(res)
# This code is contributed by rameshtravel07.
// C# program of Next Greater Frequency Element
using System;
using System.Collections.Generic;
class GFG {
static Stack<Tuple<int,int>> mystack = new Stack<Tuple<int,int>>();
static Dictionary<int, int> mymap = new Dictionary<int, int>();
/*NFG function to find the next greater frequency
element for each element and for placing it in the
resultant array */
static void NGF(int[] arr,int[] res) {
int n = arr.Length;
// Initially store the frequencies of all elements
// in a hashmap
for(int i = 0; i < n; i++) {
if(mymap.ContainsKey(arr[i]))
mymap[arr[i]] = mymap[arr[i]] + 1;
else
mymap[arr[i]] = 1;
}
// Get the frequency of the last element
int curr_freq = mymap[arr[n-1]];
// push it to the stack
mystack.Push(new Tuple<int,int>(arr[n-1],curr_freq));
// place -1 as next greater freq for the last
// element as it does not have next greater.
res[n-1] = -1;
// iterate through array in reverse order
for(int i = n-2;i>=0;i--) {
curr_freq = mymap[arr[i]];
/* If the frequency of the element which is
pointed by the top of stack is greater
than frequency of the current element
then push the current position i in stack*/
while(mystack.Count > 0 && curr_freq >= mystack.Peek().Item2)
mystack.Pop();
// If the stack is empty, place -1. If it is not empty
// then we will have next higher freq element at the top of the stack.
res[i] = (mystack.Count == 0) ? -1 : mystack.Peek().Item1;
// push the element at current position
mystack.Push(new Tuple<int,int>(arr[i],mymap[arr[i]]));
}
}
// Driver code
static void Main() {
int[] arr = {1, 1, 1, 2, 2, 2, 2, 11, 3, 3};
int[] res = new int[arr.Length];
NGF(arr, res);
Console.Write("[");
for(int i = 0; i < arr.Length - 1; i++)
{
Console.Write(res[i] + ", ");
}
Console.Write(res[arr.Length - 1] + "]");
}
}
// This code is contributed by mukesh07.
class Pair {
constructor(data, freq) {
this.data = data;
this.freq = freq;
}
}
function NGF(arr) {
let n = arr.length;
let mystack = [];
let mymap = new Map();
let res = new Array(n);
// Step 1: Calculate frequency of each element
for (let i = 0; i < n; i++) {
mymap.set(arr[i], (mymap.get(arr[i]) || 0) + 1);
}
// Step 2: Process elements in reverse order
for (let i = n - 1; i >= 0; i--) {
let curr_freq = mymap.get(arr[i]);
// Remove elements with lesser or equal frequency
while (mystack.length > 0 && curr_freq >= mystack[mystack.length - 1].freq) {
mystack.pop();
}
// Assign next greater frequency element
res[i] = mystack.length === 0 ? -1 : mystack[mystack.length - 1].data;
// Push current element into stack
mystack.push(new Pair(arr[i], curr_freq));
}
return res;
}
// Driver function
let arr = [1, 1, 1, 2, 2, 2, 2, 11, 3, 3];
let result = NGF(arr);
// Print the result
console.log(result.join(" "));
Output[2, 2, 2, -1, -1, -1, -1, 3, -1, -1]
Time Complexity: O(n)
Auxiliary Space: O(n) for hashmap and stack
Similar Reads
Stack Data Structure
A Stack is a linear data structure that follows a particular order in which the operations are performed. The order may be LIFO(Last In First Out) or FILO(First In Last Out). LIFO implies that the element that is inserted last, comes out first and FILO implies that the element that is inserted first
3 min read
What is Stack Data Structure? A Complete Tutorial
Stack is a linear data structure that follows LIFO (Last In First Out) Principle, the last element inserted is the first to be popped out. It means both insertion and deletion operations happen at one end only. LIFO(Last In First Out) PrincipleHere are some real world examples of LIFO Consider a sta
4 min read
Applications, Advantages and Disadvantages of Stack
A stack is a linear data structure in which the insertion of a new element and removal of an existing element takes place at the same end represented as the top of the stack. Applications of Stacks:Function calls: Stacks are used to keep track of the return addresses of function calls, allowing the
2 min read
Implement a stack using singly linked list
To implement a stack using a singly linked list, we need to ensure that all operations follow the LIFO (Last In, First Out) principle. This means that the most recently added element is always the first one to be removed. In this approach, we use a singly linked list, where each node contains data a
13 min read
Introduction to Monotonic Stack - Data Structure and Algorithm Tutorials
A monotonic stack is a special data structure used in algorithmic problem-solving. Monotonic Stack maintaining elements in either increasing or decreasing order. It is commonly used to efficiently solve problems such as finding the next greater or smaller element in an array etc. Table of Content Wh
12 min read
Difference Between Stack and Queue Data Structures
In computer science, data structures are fundamental concepts that are crucial for organizing and storing data efficiently. Among the various data structures, stacks and queues are two of the most basic yet essential structures used in programming and algorithm design. Despite their simplicity, they
4 min read
Stack implementation in different language
Stack in C++ STL
In C++, stack container follows LIFO (Last In First Out) order of insertion and deletion. It means that most recently inserted element is removed first and the first inserted element will be removed last. This is done by inserting and deleting elements at only one end of the stack which is generally
5 min read
Stack Class in Java
The Java Collection framework provides a Stack class, which implements a Stack data structure. The class is based on the basic principle of LIFO (last-in-first-out). Besides the basic push and pop operations, the class also provides three more functions, such as empty, search, and peek. The Stack cl
12 min read
Stack in Python
A stack is a linear data structure that stores items in a Last-In/First-Out (LIFO) or First-In/Last-Out (FILO) manner. In stack, a new element is added at one end and an element is removed from that end only. The insert and delete operations are often called push and pop. The functions associated wi
8 min read
C# Stack with Examples
In C# a Stack is a Collection that follows the Last-In-First-Out (LIFO) principle. It is used when we need last-in, first-out access to items. In C# there are both generic and non-generic types of Stacks. The generic stack is in the System.Collections.Generic namespace, while the non-generic stack i
6 min read
Implementation of Stack in JavaScript
A stack is a fundamental data structure in computer science that follows the Last In, First Out (LIFO) principle. This means that the last element added to the stack will be the first one to be removed. Stacks are widely used in various applications, such as function call management, undo mechanisms
4 min read
Stack in Scala
A stack is a data structure that follows the last-in, first-out(LIFO) principle. We can add or remove element only from one end called top. Scala has both mutable and immutable versions of a stack. Syntax : import scala.collection.mutable.Stack var s = Stack[type]() // OR var s = Stack(val1, val2, v
3 min read
Some questions related to Stack implementation
Design and Implement Special Stack Data Structure
Design a Data Structure SpecialStack that supports all the stack operations like push(), pop(), isEmpty(), isFull() and an additional operation getMin() which should return minimum element from the SpecialStack. All these operations of SpecialStack must be O(1). To implement SpecialStack, you should
1 min read
Implement two Stacks in an Array
Create a data structure twoStacks that represent two stacks. Implementation of twoStacks should use only one array, i.e., both stacks should use the same array for storing elements. Following functions must be supported by twoStacks. push1(int x) --> pushes x to first stack push2(int x) --> pu
12 min read
Implement Stack using Queues
Implement a stack using queues. The stack should support the following operations: Push(x): Push an element onto the stack.Pop(): Pop the element from the top of the stack and return it. A Stack can be implemented using two queues. Let Stack to be implemented be 's' and queues used to implement are
15+ min read
Implement k stacks in an array
Given an array of size n, the task is to implement k stacks using a single array. We mainly need to perform the following type of queries on the stack. push(x, i) : This operations pushes the element x into stack i pop(i) : This operation pops the top of stack i Here i varies from 0 to k-1 Naive App
15+ min read
Design a stack that supports getMin() in O(1) time
Design a Data Structure SpecialStack that supports all the stack operations like push(), pop(), peek() and an additional operation getMin() which should return minimum element from the SpecialStack. All these operations of SpecialStack must have a time complexity of O(1). Example: Input: queries = [
15+ min read
Implement a stack using single queue
We are given a queue data structure, the task is to implement a stack using a single queue. Also Read: Stack using two queues The idea is to keep the newly inserted element always at the front of the queue, preserving the order of previous elements by appending the new element at the back and rotati
5 min read
How to implement stack using priority queue or heap?
How to Implement stack using a priority queue(using min heap)? Asked In: Microsoft, Adobe. Solution: In the priority queue, we assign priority to the elements that are being pushed. A stack requires elements to be processed in the Last in First Out manner. The idea is to associate a count that dete
6 min read
Create a customized data structure which evaluates functions in O(1)
Create a customized data structure such that it has functions :- GetLastElement(); RemoveLastElement(); AddElement() GetMin() All the functions should be of O(1) Question Source : amazon interview questions Approach : create a custom stack of type structure with two elements, (element, min_till_now)
7 min read
Implement Stack and Queue using Deque
Deque also known as double ended queue, as name suggests is a special kind of queue in which insertions and deletions can be done at the last as well as at the beginning. A link-list representation of deque is such that each node points to the next node as well as the previous node. So that insertio
15 min read
Easy problems on Stack
Infix to Postfix Expression
Write a program to convert an Infix expression to Postfix form. Infix expression: The expression of the form "a operator b" (a + b) i.e., when an operator is in-between every pair of operands.Postfix expression: The expression of the form "a b operator" (ab+) i.e., When every pair of operands is fol
9 min read
Prefix to Infix Conversion
Infix : An expression is called the Infix expression if the operator appears in between the operands in the expression. Simply of the form (operand1 operator operand2). Example : (A+B) * (C-D) Prefix : An expression is called the prefix expression if the operator appears in the expression before the
6 min read
Prefix to Postfix Conversion
Given a Prefix expression, convert it into a Postfix expression. Conversion of Prefix expression directly to Postfix without going through the process of converting them first to Infix and then to Postfix is much better in terms of computation and better understanding the expression (Computers evalu
6 min read
Postfix to Prefix Conversion
Postfix: An expression is called the postfix expression if the operator appears in the expression after the operands. Simply of the form (operand1 operand2 operator). Example : AB+CD-* (Infix : (A+B) * (C-D) ) Prefix : An expression is called the prefix expression if the operator appears in the expr
7 min read
Postfix to Infix
Postfix to infix conversion involves transforming expressions where operators follow their operands (postfix notation) into standard mathematical expressions with operators placed between operands (infix notation). This conversion improves readability and understanding. Infix expression: The express
5 min read
Convert Infix To Prefix Notation
Given an infix expression consisting of operators (+, -, *, /, ^) and operands (lowercase characters), the task is to convert it to a prefix expression. Infix Expression: The expression of type a 'operator' b (a+b, where + is an operator) i.e., when the operator is between two operands. Prefix Expre
8 min read
Valid Parentheses in an Expression
Given a string s representing an expression containing various types of brackets: {}, (), and [], the task is to determine whether the brackets in the expression are balanced or not. A balanced expression is one where every opening bracket has a corresponding closing bracket in the correct order. Ex
8 min read
Arithmetic Expression Evaluation
The stack organization is very effective in evaluating arithmetic expressions. Expressions are usually represented in what is known as Infix notation, in which each operator is written between two operands (i.e., A + B). With this notation, we must distinguish between ( A + B )*C and A + ( B * C ) b
2 min read
Evaluation of Postfix Expression
Given a postfix expression, the task is to evaluate the postfix expression. A Postfix expression is of the form "a b operator" ("a b +") i.e., a pair of operands is followed by an operator. Examples: Input: arr = ["2", "3", "1", "*", "+", "9", "-"]Output: -4Explanation: If the expression is converte
6 min read
How to Reverse a Stack using Recursion
Write a program to reverse a stack using recursion, without using any loop. Example: Input: elements present in stack from top to bottom 4 3 2 1Output: 1 2 3 4 Input: elements present in stack from top to bottom 1 2 3Output: 3 2 1 The idea of the solution is to hold all values in Function Call Stack
4 min read
Reverse individual words
Given string str, we need to print the reverse of individual words. Examples: Input: Hello WorldOutput: olleH dlroWExplanation: Each word in "Hello World" is reversed individually, preserving the original order, resulting in "olleH dlroW". Input: Geeks for GeeksOutput: skeeG rof skeeG [Expected Appr
5 min read
Reverse a String using Stack
Given a string str, the task is to reverse it using stack. Example: Input: s = "GeeksQuiz"Output: ziuQskeeG Input: s = "abc"Output: cba Also read: Reverse a String – Complete Tutorial. As we all know, stacks work on the principle of first in, last out. After popping all the elements and placing them
3 min read
Reversing a Queue
You are given a queue Q, and your task is to reverse the elements of the queue. You are only allowed to use the following standard queue operations: enqueue(x): Add an item x to the rear of the queue.dequeue(): Remove an item from the front of the queue.empty(): Check if the queue is empty or not.Ex
4 min read
Intermediate problems on Stack
How to create mergeable stack?
Design a stack with the following operations. push(Stack s, x): Adds an item x to stack s pop(Stack s): Removes the top item from stack s merge(Stack s1, Stack s2): Merge contents of s2 into s1. Time Complexity of all above operations should be O(1). If we use array implementation of the stack, then
8 min read
The Stock Span Problem
The stock span problem is a financial problem where we have a series of daily price quotes for a stock denoted by an array arr[] and the task is to calculate the span of the stock's price for all days. The span of the stock's price on ith day represents the maximum number of consecutive days leading
11 min read
Next Greater Element (NGE) for every element in given Array
Given an array arr[] of integers, the task is to find the Next Greater Element for each element of the array in order of their appearance in the array. Note: The Next Greater Element for an element x is the first greater element on the right side of x in the array. Elements for which no greater elem
9 min read
Next Greater Frequency Element
Given an array, for each element find the value of the nearest element to the right which is having a frequency greater than that of the current element. If there does not exist an answer for a position, then make the value '-1'. Examples: Input : a[] = [1, 1, 2, 3, 4, 2, 1] Output : [-1, -1, 1, 2,
15+ min read
Maximum product of indexes of next greater on left and right
Given an array arr[1..n], for each element at position i (1 <= i <= n), define the following: left(i) is the closest index j such that j < i and arr[j] > arr[i]. If no such j exists, then left(i) = 0.right(i) is the closest index k such that k > i and arr[k] > arr[i]. If no such k
11 min read
Iterative Tower of Hanoi
The Tower of Hanoi is a mathematical puzzle with three poles and stacked disks of different sizes. The goal is to move all disks from the source pole to the destination pole using an auxiliary pole, following two rules: Only one disk can be moved at a time.A larger disk cannot be placed on a smaller
6 min read
Sort a stack using a temporary stack
Given a stack of integers, sort it in ascending order using another temporary stack. Examples: Input: [34, 3, 31, 98, 92, 23]Output: [3, 23, 31, 34, 92, 98]Explanation: After Sorting the given array it would be look like as [3, 23, 31, 34, 92, 98]Input: [3, 5, 1, 4, 2, 8]Output: [1, 2, 3, 4, 5, 8] A
6 min read
Reverse a stack without using extra space in O(n)
Reverse a Stack without using recursion and extra space. Even the functional Stack is not allowed. Examples: Input : 1->2->3->4 Output : 4->3->2->1 Input : 6->5->4 Output : 4->5->6 We have discussed a way of reversing a stack in the below post.Reverse a Stack using Recu
6 min read
Delete middle element of a stack
Given a stack with push(), pop(), and empty() operations, The task is to delete the middle element of it without using any additional data structure. Input: s = [10, 20, 30, 40, 50]Output: [50, 40, 20, 10]Explanation: The bottom-most element will be 10 and the top-most element will be 50. Middle ele
9 min read
Check if a queue can be sorted into another queue using a stack
Given a Queue consisting of first n natural numbers (in random order). The task is to check whether the given Queue elements can be arranged in increasing order in another Queue using a stack. The operation allowed are: Push and pop elements from the stack Pop (Or Dequeue) from the given Queue. Push
9 min read
Check if an array is stack sortable
Given an array arr[] of n distinct elements, where each element is between 1 and n (inclusive), determine if it is stack-sortable.Note: An array a[] is considered stack-sortable if it can be rearranged into a sorted array b[] using a temporary stack stk with the following operations: Remove the firs
6 min read
Largest Rectangular Area in a Histogram
Given a histogram represented by an array arr[], where each element of the array denotes the height of the bars in the histogram. All bars have the same width of 1 unit. Task is to find the largest rectangular area possible in a given histogram where the largest rectangle can be made of a number of
15+ min read
Maximum of minimums of every window size in a given array
Given an integer array arr[] of size n, the task is to find the maximum of the minimums for every window size in the given array, where the window size ranges from 1 to n. Example: Input: arr[] = [10, 20, 30]Output: [30, 20, 10]Explanation: First element in output indicates maximum of minimums of al
14 min read
Find index of closing bracket for a given opening bracket in an expression
Given a string with brackets. If the start index of the open bracket is given, find the index of the closing bracket. Examples: Input : string = [ABC[23]][89] index = 0 Output : 8 The opening bracket at index 0 corresponds to closing bracket at index 8.Recommended PracticeClosing bracket indexTry It
7 min read
Maximum difference between nearest left and right smaller elements
Given an array of integers, the task is to find the maximum absolute difference between the nearest left and the right smaller element of every element in the array. Note: If there is no smaller element on right side or left side of any element then we take zero as the smaller element. For example f
12 min read
Delete consecutive same words in a sequence
Given an array of n strings arr[]. The task is to determine the number of words remaining after pairwise destruction. If two consecutive words in the array are identical, they cancel each other out. This process continues until no more eliminations are possible. Examples: Input: arr[] = ["gfg", "for
7 min read
Check mirror in n-ary tree
Given two n-ary trees, determine whether they are mirror images of each other. Each tree is described by e edges, where e denotes the number of edges in both trees. Two arrays A[]and B[] are provided, where each array contains 2*e space-separated values representing the edges of both trees. Each edg
11 min read
Reverse a number using stack
Given a number , write a program to reverse this number using stack. Examples: Input : 365Output : 563Input : 6899Output : 9986We have already discussed the simple method to reverse a number in this post. In this post we will discuss about how to reverse a number using stack.The idea to do this is t
5 min read
Reversing the first K elements of a Queue
Given an integer k and a queue of integers, The task is to reverse the order of the first k elements of the queue, leaving the other elements in the same relative order. Only following standard operations are allowed on the queue. enqueue(x): Add an item x to rear of queuedequeue(): Remove an item f
13 min read