下一个更大的频率元素

给定一个数组，对于每个元素，找到右侧最近元素的值，该值的频率大于当前元素的频率。如果某个位置不存在答案，则将值设为“-1”。

例子：

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]

幼稚的方法：
一种简单的散列技术是使用值作为索引用于存储每个元素的频率。创建一个列表，假设存储数组中每个数字的频率。 （需要单次遍历）。现在使用两个循环。
外循环一一选取所有元素。
内循环查找频率大于当前元素频率的第一个元素。
如果找到更大的频率元素，则打印该元素，否则打印 -1。
时间复杂度： O(n*n)

有效的方法：
我们可以使用散列和堆栈数据结构来有效地解决许多情况。一种简单的散列技术是使用值作为索引，使用每个元素的频率作为值。我们使用堆栈数据结构来存储元素在数组中的位置。

1) Create a list to use values as index to store frequency of each element. 
2) Push the position of first element to stack. 
3) Pick rest of the position of elements one by one and follow following steps in loop. 
…….a) Mark the position of current element as ‘i’ . 
……. b) 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 
……. c) 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: 
…….i) continue popping the stack 
…….ii) if the condition in step c fails then push the current position i to the stack 
4) 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.

下面是上述问题的实现。

C++

// C++ program of Next Greater Frequency Element
#include 
#include 
#include 
 
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 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

// 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 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[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

Python3

'''NFG function to find the next greater frequency
   element for each element in the array'''
 
 
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[a[i]] = 0
    for i in a:
        freq[a[i]] += 1
 
    # res to store the value of next greater
    # frequency element for each element
    res = [0]*n
 
    # initialize top of stack to -1
    top = -1
 
    # push the first position of array in the stack
    top += 1
    stack[top] = 0
 
    # now iterate for the rest of elements
    for i in range(1, n):
 
        ''' 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[stack[top]]] > freq[a[i]]):
            top += 1
            stack[top] = 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 (top > -1 and freq[a[stack[top]]] < freq[a[i]]):
                res[stack[top]] = a[i]
                top -= 1
 
            # now push the current element
            top += 1
            stack[top] = i
 
    '''After iterating over the loop, the remaining
    position of elements in 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 next
    # greater frequency element
    return res
 
 
# Driver Code
print(NFG([1, 1, 2, 3, 4, 2, 1], 7))

C#

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

    // Javascript program of Next Greater Frequency Element
     
    /*NFG function to find the
    next greater frequency
    element for each element
    in the array*/
    function NFG(a, n, freq)
    {
  
        // stack data structure to store
        // the position of array element
        let s = [];
        s.push(0);
  
        // res to store the value of next greater
        // frequency element for each element
        let res = new Array(n);
        for (let i = 0; i < n; i++)
            res[i] = 0;
  
        for (let 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[s.length - 1]]] > 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[s.length - 1]]]
                           < freq[a[i]]
                       && s.length > 0)
                {
                    res[s[s.length - 1]] = a[i];
                    s.pop();
                }
  
                // now Push the current element
                s.push(i);
            }
        }
  
        while (s.length > 0)
        {
            res[s[s.length - 1]] = -1;
            s.pop();
        }
         document.write("[");
        for (let i = 0; i < n - 1; i++)
        {
         
            // Print the res list containing next
            // greater frequency element
            document.write(res[i] + ", ");
        }
        document.write(res[n - 1] + "]");
    }
     
    let a = [ 1, 1, 2, 3, 4, 2, 1 ];
    let len = 7;
    let max = Number.MIN_VALUE;
    for (let i = 0; i < len; i++)
    {
     
      // Getting the max element of the array
      if (a[i] > max)
      {
        max = a[i];
      }
    }
    let freq = new Array(max + 1);
 
    for (let i = 0; i < max + 1; i++)
      freq[i] = 0;
 
    // Calculating frequency of each element
    for (let i = 0; i < len; i++)
    {
      freq[a[i]]++;
    }
    NFG(a, len, freq);
     
    // This code is contributed by vaibhavrabadiya117.

输出：

[-1, -1, 1, 2, 2, 1, -1]

时间复杂度： O(n)。

空间高效的方法：使用哈希映射而不是上述方法中提到的列表。

脚步：

1. 创建一个类对来存储 pair 和 pair。
2. 创建一个以 pair 作为泛型的搭扣映射，将键存储为元素，将值存储为每个元素的频率。
3. 迭代数组并将元素及其频率保存在哈希图中。
4. 创建一个 res 数组来存储结果数组。
5. 最初使 res[n-1] = -1 并将最后的元素连同其频率一起推入堆栈。
6. 以相反的顺序遍历数组。
7. 如果指向栈顶元素的频率小于当前元素的频率并且栈不为空，则弹出。
8. 继续直到循环失败。
9. 如果堆栈为空，则表示没有频率更高的元素。因此，将 -1 作为结果数组中的下一个更高频率元素。
10. 如果栈不为空，则说明栈顶有较高频率的元素。将其作为下一个更高的频率放入合成阵列中。
11. 推动当前元素及其频率。

Java

// Java program of Next Greater Frequency Element
import java.util.*;
 
class GFG {
    Stack mystack = new Stack<>();
    HashMap 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=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

Javascript

// Javascript program of Next Greater Frequency Element
 
class Pair
{
    constructor(data,freq)
    {
        this.data = data;
            this.freq = freq;
    }
}
 
let mystack = [];
let  mymap = new Map();
 
/*NFG function to find the next greater frequency
    element for each element and for placing it in the
    resultant array */
function NGF(arr,res)
{
    let n = arr.length;
          
        //Initially store the frequencies of all elements
        //in a hashmap
        for(let i = 0;i<n;i++) {
            if(mymap.has(arr[i]))
                mymap.set(arr[i], mymap.get(arr[i]) + 1);
            else
                mymap.set(arr[i], 1);
        }
          
        // Get the frequency of the last element
        let 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(let 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.length!=0  &&  curr_freq >= mystack[mystack.length-1].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.length==0) ? -1 : mystack[mystack.length-1].data;
              
            // push the element at current position
            mystack.push(new Pair(arr[i],mymap.get(arr[i])));
        }
}
 
// Driver function
let arr=[1, 1, 1, 2, 2, 2, 2, 11, 3, 3];
let res = new Array(arr.length);
NGF(arr, res);
document.write((res).join(" "));
 
// This code is contributed by avanitrachhadiya2155

输出

[2, 2, 2, -1, -1, -1, -1, 3, -1, -1]

时间复杂度： O(n)。

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。