按频率降序对数组元素进行排序

给定一个由N 个整数组成的数组arr[] 。任务是按照元素出现的频率降序对数组arr[]进行排序。
注意：如果两个元素的频率相同，则较小的元素应该在前。
例子：

Input: arr[] = { 4, 4, 5, 6, 4, 2, 2, 8, 5 } 
Output: 4 4 4 2 2 5 5 6 8
Input: arr[] = { 9, 9, 5, 8, 5 } 
Output: 5 5 9 9 8 
 

方法：

• 将所有元素的频率存储在数组arr[] 中。
• 对于 arr[] = { 4, 4, 5, 6, 4, 2, 2, 8, 5 }
  上述数组的频率数组为：
  频率[] = { 0, 0, 2, 0, 3, 2, 0, 1, 0, 1}
• 遍历频率数组，对于所有频率大于1的元素，将数组arr[] 中的值更新为：

freq[2] = 2 
arr[0] = 100000*freq[2] + (100000 – 2) = 299998 
freq[4] = 3 
arr[1] = 100000*freq[2] + (100000 – 4) = 399996 
freq[5] = 2 
arr[2] = 100000*freq[2] + (100000 – 5) = 299995 
freq[6] = 2 
arr[3] = 100000*freq[2] + (100000 – 6) = 199994 
freq[8] = 2 
arr[4] = 100000*freq[2] + (100000 – 2) = 199994 
Now array becomes: 
arr[] = {299998, 399996, 299995, 199994, 199992, 2, 2, 8, 5} 
 

• 按降序对数组arr[]进行排序。
• 遍历数组arr[]并根据步骤 2 中数组元素的更新获取该元素的元素和频率，请执行以下操作：

To get the frequency of current element: 
frequency = arr[i]/100000; 
To get the value: 
value = 100000 – arr[i]%100000 
 

例如：

if arr[i] = 399996 
frequency = arr[i]/100000 = 399996/100000 = 3 
value = 100000 – arr[i]%100000 = 100000 – 99996 = 4 
The element 4 is having frequency 3. 
 

• 对于arr[] 中的每个元素，在每个索引处找到值和频率(比如f )并打印值f次。

下面是上述方法的实现：

C++

// C++ program to sort an array in
// decreasing order of their frequnecy
#include "bits/stdc++.h"
using namespace std;
 
// Function that return the index
// upto all the array elements are
// updated.
int sortByFreq(int* arr, int n)
{
 
    // Initialise maxE = -1
    int maxE = -1;
 
    // Find the maximum element of
    // arr[]
    for (int i = 0; i < n; i++) {
        maxE = max(maxE, arr[i]);
    }
 
    // Create frequency array freq[]
    int freq[maxE + 1] = { 0 };
 
    // Update the frequency array as
    // per the occurence of element in
    // arr[]
    for (int i = 0; i < n; i++) {
        freq[arr[i]]++;
    }
 
    // Initialise cnt to 0
    int cnt = 0;
 
    // Traversing freq[]
    for (int i = 0; i <= maxE; i++) {
 
        // If freq of an element is
        // greater than 0 update the
        // value of arr[] at index cnt
        // & increment cnt
        if (freq[i] > 0) {
 
            int value = 100000 - i;
            arr[cnt] = 100000 * freq[i] + value;
            cnt++;
        }
    }
 
    // Return cnt
    return cnt;
}
 
// Function that print array arr[]
// elements in sorted order
void printSortedArray(int* arr, int cnt)
{
 
    // Traversing arr[] till index cnt
    for (int i = 0; i < cnt; i++) {
 
        // Find frequency of elements
        int frequency = arr[i] / 100000;
 
        // Find value at index i
        int value = 100000 - (arr[i] % 100000);
 
        // Traversing till frequency
        // to print value at index i
        for (int j = 0; j < frequency; j++) {
            cout << value << ' ';
        }
    }
}
 
// Driver code
int main()
{
 
    int arr[] = { 4, 4, 5, 6, 4, 2, 2, 8, 5 };
 
    // Size of array arr[]
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Function call to get cnt
    int cnt = sortByFreq(arr, n);
 
    // Sort the arr[] in decreasing order
    sort(arr, arr + cnt, greater());
 
    // Function that prints elements
    // in decreasing order
    printSortedArray(arr, cnt);
 
    return 0;
}

Java

// Java program to sort an array in
// decreasing order of their frequnecy
import java.util.*;
 
class GFG{
  
// Function that return the index
// upto all the array elements are
// updated.
static int sortByFreq(Integer []arr, int n)
{
  
    // Initialise maxE = -1
    int maxE = -1;
  
    // Find the maximum element of
    // arr[]
    for (int i = 0; i < n; i++) {
        maxE = Math.max(maxE, arr[i]);
    }
  
    // Create frequency array freq[]
    int freq[] = new int[maxE + 1];
  
    // Update the frequency array as
    // per the occurence of element in
    // arr[]
    for (int i = 0; i < n; i++) {
        freq[arr[i]]++;
    }
  
    // Initialise cnt to 0
    int cnt = 0;
  
    // Traversing freq[]
    for (int i = 0; i <= maxE; i++) {
  
        // If freq of an element is
        // greater than 0 update the
        // value of arr[] at index cnt
        // & increment cnt
        if (freq[i] > 0) {
  
            int value = 100000 - i;
            arr[cnt] = 100000 * freq[i] + value;
            cnt++;
        }
    }
  
    // Return cnt
    return cnt;
}
  
// Function that print array arr[]
// elements in sorted order
static void printSortedArray(Integer []arr, int cnt)
{
  
    // Traversing arr[] till index cnt
    for (int i = 0; i < cnt; i++) {
  
        // Find frequency of elements
        int frequency = arr[i] / 100000;
  
        // Find value at index i
        int value = 100000 - (arr[i] % 100000);
  
        // Traversing till frequency
        // to print value at index i
        for (int j = 0; j < frequency; j++) {
            System.out.print(value + " ");
        }
    }
}
  
// Driver code
public static void main(String[] args)
{
  
    Integer arr[] = { 4, 4, 5, 6, 4, 2, 2, 8, 5 };
  
    // Size of array arr[]
    int n = arr.length;
  
    // Function call to get cnt
    int cnt = sortByFreq(arr, n);
  
    // Sort the arr[] in decreasing order
    Arrays.sort(arr, Collections.reverseOrder());
  
    // Function that prints elements
    // in decreasing order
    printSortedArray(arr, cnt);
  
}
}
 
// This code is contributed by sapnasingh4991

Python3

# Python program to sort an array in
# decreasing order of their frequnecy
 
# Function that return the index
# upto all the array elements are
# updated.
def sortByFreq(arr, n):
 
    # Initialise maxE = -1
    maxE = -1;
 
    # Find the maximum element of
    # arr[]
    for i in range(n):
        maxE = max(maxE, arr[i])
 
    # Create frequency array freq[]
    freq = [0]*(maxE + 1);
 
    # Update the frequency array as
    # per the occurence of element in
    # arr[]
    for i in range(n):
        freq[arr[i]] += 1;
     
    # Initialise cnt to 0
    cnt = 0;
 
    # Traversing freq[]
    for i in range(maxE+1):
 
        # If freq of an element is
        # greater than 0 update the
        # value of arr[] at index cnt
        # & increment cnt
        if (freq[i] > 0):
 
            value = 100000 - i;
            arr[cnt] = 100000 * freq[i] + value;
            cnt += 1;
         
    # Return cnt
    return cnt;
 
# Function that print array arr[]
# elements in sorted order
def printSortedArray(arr, cnt):
 
    # Traversing arr[] till index cnt
    for i in range(cnt):
 
        # Find frequency of elements
        frequency = arr[i] / 100000;
 
        # Find value at index i
        value = 100000 - (arr[i] % 100000);
 
        # Traversing till frequency
        # to print value at index i
        for j in range(int(frequency)):
            print(value, end=" ")
             
# Driver code
if __name__=='__main__':
 
    arr = [ 4, 4, 5, 6, 4, 2, 2, 8, 5 ]
 
    # Size of array arr[]
    n = len(arr)
 
    # Function call to get cnt
    cnt = sortByFreq(arr, n);
 
    # Sort the arr[] in decreasing order
    arr.sort(reverse = True)
 
    # Function that prints elements
    # in decreasing order
    printSortedArray(arr, cnt);
 
# This code is contributed by Princi Singh

C#

// C# program to sort an array in
// decreasing order of their frequnecy
using System;
 
class GFG {
 
  // Function that return the index
  // upto all the array elements are
  // updated.
  static int sortByFreq(int[] arr, int n)
  {
 
    // Initialise maxE = -1
    int maxE = -1;
 
    // Find the maximum element of
    // arr[]
    for (int i = 0; i < n; i++)
    {
      maxE = Math.Max(maxE, arr[i]);
    }
 
    // Create frequency array freq[]
    int[] freq = new int[maxE + 1];
 
    // Update the frequency array as
    // per the occurence of element in
    // arr[]
    for (int i = 0; i < n; i++)
    {
      freq[arr[i]]++;
    }
 
    // Initialise cnt to 0
    int cnt = 0;
 
    // Traversing freq[]
    for (int i = 0; i <= maxE; i++)
    {
 
      // If freq of an element is
      // greater than 0 update the
      // value of arr[] at index cnt
      // & increment cnt
      if (freq[i] > 0)
      {
        int value = 100000 - i;
        arr[cnt] = 100000 * freq[i] + value;
        cnt++;
      }
    }
 
    // Return cnt
    return cnt;
  }
 
  // Function that print array arr[]
  // elements in sorted order
  static void printSortedArray(int[] arr, int cnt)
  {
 
    // Traversing arr[] till index cnt
    for (int i = 0; i < cnt; i++)
    {
 
      // Find frequency of elements
      int frequency = arr[i] / 100000;
 
      // Find value at index i
      int value = 100000 - (arr[i] % 100000);
 
      // Traversing till frequency
      // to print value at index i
      for (int j = 0; j < frequency; j++)
      {
        Console.Write(value + " ");
      }
    }
  }
 
  // Driver code
  public static void Main()
  {
    int[] arr = { 4, 4, 5, 6, 4, 2, 2, 8, 5 };
 
    // Size of array arr[]
    int n = arr.Length;
 
    // Function call to get cnt
    int cnt = sortByFreq(arr, n);
 
    // Sort the arr[] in decreasing order
    Array.Sort(arr);
    Array.Reverse(arr);
 
    // Function that prints elements
    // in decreasing order
    printSortedArray(arr, cnt);
  }
}
 
// This code is contributed by subhamahato348

Javascript

 
      // JavaScript program to sort an array in
      // decreasing order of their frequnecy
       
      // Function that return the index
      // upto all the array elements are
      // updated.
      function sortByFreq(arr, n) {
        // Initialise maxE = -1
        var maxE = -1;
 
        // Find the maximum element of
        // arr[]
        for (var i = 0; i < n; i++) {
          maxE = Math.max(maxE, arr[i]);
        }
 
        // Create frequency array freq[]
        var freq = new Array(maxE + 1).fill(0);
 
        // Update the frequency array as
        // per the occurence of element in
        // arr[]
        for (var i = 0; i < n; i++) {
          freq[arr[i]]++;
        }
 
        // Initialise cnt to 0
        var cnt = 0;
 
        // Traversing freq[]
        for (var i = 0; i <= maxE; i++) {
          // If freq of an element is
          // greater than 0 update the
          // value of arr[] at index cnt
          // & increment cnt
          if (freq[i] > 0) {
            var value = 100000 - i;
            arr[cnt] = 100000 * freq[i] + value;
            cnt++;
          }
        }
 
        // Return cnt
        return cnt;
      }
 
      // Function that print array arr[]
      // elements in sorted order
      function printSortedArray(arr, cnt) {
        // Traversing arr[] till index cnt
        for (var i = 0; i < cnt; i++) {
          // Find frequency of elements
          var frequency = parseInt(arr[i] / 100000);
 
          // Find value at index i
          var value = 100000 - (arr[i] % 100000);
 
          // Traversing till frequency
          // to print value at index i
          for (var j = 0; j < frequency; j++) {
            document.write(value + " ");
          }
        }
      }
 
      // Driver code
      var arr = [4, 4, 5, 6, 4, 2, 2, 8, 5];
 
      // Size of array arr[]
      var n = arr.length;
 
      // Function call to get cnt
      var cnt = sortByFreq(arr, n);
 
      // Sort the arr[] in decreasing order
      arr.sort((a, b) => b - a);
 
      // Function that prints elements
      // in decreasing order
      printSortedArray(arr, cnt);
       

输出：

4 4 4 2 2 5 5 6 8

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

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live