打印至少出现 M 次的所有数组元素

给定一个由N 个整数和一个正整数M组成的数组arr[] ，任务是找到至少出现M次的数组元素的数量。

例子：

Input: arr[] = {2, 3, 2, 2, 3, 5, 6, 3}, M = 2
Output: 2 3
Explanation:
In the given array arr[], the element that occurs at least M number of times are {2, 3}.

Input: arr[] = {1, 32, 2, 1, 33, 5, 1, 5}, M = 2
Output: 1 5

朴素的方法：解决问题的最简单的方法如下：

• 从左到右遍历数组
• 检查元素是否已经出现在较早的遍历中。如果出现检查下一个元素。否则再次从第 i 个位置到第(n – 1) 个位置遍历数组。
• 如果频率>= M 。打印元素。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to find the number of array
// elements with frequency at least M
void printElements(int arr[], int N, int M)
{
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        int j;
        for (j = i - 1; j >= 0; j--) {
            if (arr[i] == arr[j])
                break;
        }
 
        // If the element appeared before
        if (j >= 0)
            continue;
 
        // Count frequency of the element
        int freq = 0;
        for (j = i; j < N; j++) {
            if (arr[j] == arr[i])
                freq++;
        }
 
        if (freq >= M)
            cout << arr[i] << " ";
    }
}
 
// Driver Code
int main()
{
    int arr[] = { 2, 3, 2, 2, 3, 5, 6, 3 };
    int M = 2;
    int N = sizeof(arr) / sizeof(arr[0]);
 
    printElements(arr, N, M);
 
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
 
class GFG{
     
// Function to find the number of array
// elements with frequency at least M
static void printElements(int[] arr, int N, int M)
{
     
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
        int j;
        for(j = i - 1; j >= 0; j--)
        {
            if (arr[i] == arr[j])
                break;
        }
 
        // If the element appeared before
        if (j >= 0)
            continue;
 
        // Count frequency of the element
        int freq = 0;
        for(j = i; j < N; j++)
        {
            if (arr[j] == arr[i])
                freq++;
        }
 
        if (freq >= M)
            System.out.print(arr[i] + " ");
    }
}
 
// Driver Code
public static void main(String[] args)
{
    int[] arr = { 2, 3, 2, 2, 3, 5, 6, 3 };
    int M = 2;
    int N = arr.length;
 
    printElements(arr, N, M);
}
}
 
// This code is contributed by subhammahato348

Python3

# Python3 program for the above approach
 
# Function to find the number of array
# elements with frequency at least M
def printElements(arr, N, M):
     
    # Traverse the array
    for  i in range(N):
        j = i - 1
         
        while j >= 0:
            if (arr[i] == arr[j]):
                break
             
            j -= 1
 
        # If the element appeared before
        if (j >= 0):
            continue
 
        # Count frequency of the element
        freq = 0
         
        for j in range(i, N):
            if (arr[j] == arr[i]):
                freq += 1
         
        if (freq >= M):
            print(arr[i], end = " ")
 
# Driver Code
arr = [ 2, 3, 2, 2, 3, 5, 6, 3 ]
M = 2
N = len(arr)
 
printElements(arr, N, M)
 
# This code is contributed by rohitsingh07052

C#

// C# program for the above approach
using System;
 
class GFG{
 
// Function to find the number of array
// elements with frequency at least M
static void printElements(int[] arr, int N, int M)
{
     
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
        int j;
        for(j = i - 1; j >= 0; j--)
        {
            if (arr[i] == arr[j])
                break;
        }
 
        // If the element appeared before
        if (j >= 0)
            continue;
 
        // Count frequency of the element
        int freq = 0;
        for(j = i; j < N; j++)
        {
            if (arr[j] == arr[i])
                freq++;
        }
 
        if (freq >= M)
            Console.Write(arr[i] + " ");
    }
}
 
// Driver Code
public static void Main()
{
    int[] arr = { 2, 3, 2, 2, 3, 5, 6, 3 };
    int M = 2;
    int N = arr.Length;
 
    printElements(arr, N, M);
}
}
 
// This code is contributed by subham348

Javascript

// Javascript program for the above approach
 
// Function to find the number of array
// elements with frequency at least M
function printElements(arr, N, M)
{
 
    // Traverse the array
    for (let i = 0; i < N; i++) {
 
        let j;
        for (j = i - 1; j >= 0; j--) {
            if (arr[i] == arr[j])
                break;
        }
 
        // If the element appeared before
        if (j >= 0)
            continue;
 
        // Count frequency of the element
        let freq = 0;
        for (j = i; j < N; j++) {
            if (arr[j] == arr[i])
                freq++;
        }
 
        if (freq >= M)
            document.write(arr[i] + " ");
    }
}
 
// Driver Code
    let arr = [ 2, 3, 2, 2, 3, 5, 6, 3 ];
    let M = 2;
    let N = arr.length;
 
    printElements(arr, N, M);
  
 // This code is contributed by subham348.

输出

2 3 

方法：给定的问题可以通过将数组元素的频率存储在 HashMap 中来解决，比如M ，并打印映射中频率至少为 M 的所有元素。

下面是上述方法的实现。

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to find the number of array
// elements with frequency at least M
void printElements(int arr[], int N, int M)
{
    // Stores the frequency of each
    // array elements
    unordered_map freq;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Update frequency of
        // current array element
        freq[arr[i]]++;
    }
 
    // Traverse the map and print array
    // elements occurring at least M times
    for (auto it : freq) {
 
        if (it.second >= M) {
            cout << it.first << " ";
        }
    }
 
    return;
}
 
// Driver Code
int main()
{
    int arr[] = { 2, 3, 2, 2,
                  3, 5, 6, 3 };
    int M = 2;
    int N = sizeof(arr) / sizeof(arr[0]);
 
    printElements(arr, N, M);
 
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG
{
 
  // Function to find the number of array
  // elements with frequency at least M
  static void printElements(int arr[], int N, int M)
  {
     
    // Stores the frequency of each
    // array elements
    HashMap freq = new HashMap<>();
 
    // Traverse the array
    for (int i = 0; i < N; i++)
    {
 
      // Update frequency of
      // current array element
      freq.put(arr[i],
               freq.getOrDefault(arr[i], 0) + 1);
    }
 
    // Traverse the map and print array
    // elements occurring at least M times
    for (int key : freq.keySet())
    {
 
      if (freq.get(key) >= M) {
        System.out.print(key + " ");
      }
    }
  }
 
  // Driver Code
  public static void main(String[] args)
  {
 
    int arr[] = { 2, 3, 2, 2, 3, 5, 6, 3 };
    int M = 2;
    int N = arr.length;
 
    printElements(arr, N, M);
  }
}
 
// This code is contributed by Kingash.

蟒蛇3

# Python3 program for the above approach
 
# Function to find the number of array
# elements with frequency at least M
def printElements(arr, N, M):
   
    # Stores the frequency of each
    # array elements
    freq = {}
 
    # Traverse the array
    for i in arr:
       
        # Update frequency of
        # current array element
        freq[i] = freq.get(i, 0) + 1
 
    # Traverse the map and prarray
    # elements occurring at least M times
    for it in freq:
 
        if (freq[it] >= M):
            print(it, end = " ")
 
    return
 
# Driver Code
if __name__ == '__main__':
    arr = [2, 3, 2, 2, 3, 5, 6, 3]
    M = 2
    N = len(arr)
 
    printElements(arr, N, M)
 
    # This code is contributed by mohit kumar 29.

C＃

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to find the number of array
// elements with frequency at least M
static void printElements(int []arr, int N, int M)
{
     
    // Stores the frequency of each
    // array elements
    Dictionary freq = new Dictionary();
 
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // Update frequency of
        // current array element
        if (freq.ContainsKey(arr[i]))
            freq[arr[i]] += 1;
        else
            freq[arr[i]] = 1;
    }
 
    // Traverse the map and print array
    // elements occurring at least M times
    foreach(var item in freq)
    {
        if (item.Value >= M)
        {
            Console.Write(item.Key + " ");
        }
    }
 
    return;
}
 
// Driver Code
public static void Main()
{
    int []arr = { 2, 3, 2, 2,
                  3, 5, 6, 3 };
    int M = 2;
    int N = arr.Length;
     
    printElements(arr, N, M);
}
}
 
// This code is contributed by SURENDRA_GANGWAR

Javascript

// Javascript program for the above approach
 
 
// Function to find the number of array
// elements with frequency at least M
function printElements(arr, N, M) {
    // Stores the frequency of each
    // array elements
    let freq = new Map();
 
    // Traverse the array
    for (let i = 0; i < N; i++) {
 
        // Update frequency of
        // current array element
        freq[arr[i]]++;
        if (freq.has(arr[i])) {
            freq.set(arr[i], freq.get(arr[i]) + 1)
        } else {
            freq.set(arr[i], 1)
        }
    }
 
    // Traverse the map and print array
    // elements occurring at least M times
    for (let it of freq) {
 
        if (it[1] >= M) {
            document.write(it[0] + " ");
        }
    }
 
    return;
}
 
// Driver Code
 
let arr = [2, 3, 2, 2,
    3, 5, 6, 3];
let M = 2;
let N = arr.length;
 
printElements(arr, N, M);
 
// This code is contributed by gfgking.

输出

2 3 

时间复杂度： O(N)
辅助空间： O(N)

方法#2：使用内置Python函数：

• 使用Counter()函数计算每个元素的频率
• 遍历频率数组并打印至少出现 m 次的所有元素。

下面是实现：

蟒蛇3

# Python3 implementation
from collections import Counter
 
# Function to find the number of array
# elements with frequency at least M
def printElements(arr, M):
 
    # Counting frequency of every element using Counter
    mp = Counter(arr)
     
    # Traverse the map and print all
    # the elements with occurrence atleast m times
    for it in mp:
        if mp[it] >= M:
            print(it, end=" ")
 
 
# Driver code
arr = [2, 3, 2, 2, 3, 5, 6, 3]
M = 2
 
printElements(arr, M)
 
# This code is contributed by vikkycirus

输出

2 3 

时间复杂度： O(N)

辅助空间： O(N)

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