Skip to content
Related Articles

Related Articles

Improve Article

C program to count frequency of each element in an array

  • Last Updated : 25 May, 2021

Given an array arr[] of size N, the task is to find the frequency of each distinct element present in the given array.

Examples:

Input: arr[] = { 1, 100000000, 3, 100000000, 3 } 
Output: { 1 : 1, 3 : 2, 100000000 : 2 } 
Explanation: 
Distinct elements of the given array are { 1, 100000000, 3 } 
Frequency of 1 in the given array is 1. 
Frequency of 100000000 in the given array is 2. 
Frequency of 3 in the given array is 2. 
Therefore, the required output is { 1 : 1, 100000000 : 2, 3 : 2 }

Input: arr[] = { 100000000, 100000000, 800000000, 100000000 } 
Output: { 100000000 : 3, 800000000 : 1}

Approach: The problem can be solved using Binary search technique. Follow the steps below to solve the problem:



Below is the implementation of the above approach:

C




// C program to implement
// the above approach
 
#include <stdio.h>
#include <stdlib.h>
 
// Comparator function to sort
// the array in ascending order
int cmp(const void* a,
        const void* b)
{
    return (*(int*)a - *(int*)b);
}
 
// Function to find the lower_bound of X
int lower_bound(int arr[], int N, int X)
{
    // Stores minimum possible
    // value of the lower_bound
    int low = 0;
 
    // Stores maximum possible
    // value of the lower_bound
    int high = N;
 
    // Calculate the upper_bound
    // of X using binary search
    while (low < high) {
 
        // Stores mid element
        // of low and high
        int mid = low + (high - low) / 2;
 
        // If X is less than
        // or equal to arr[mid]
        if (X <= arr[mid]) {
 
            // Find lower_bound in
            // the left subarray
            high = mid;
        }
 
        else {
 
            // Find lower_bound in
            // the right subarray
            low = mid + 1;
        }
    }
 
    // Return the lower_bound index
    return low;
}
 
// Function to find the upper_bound of X
int upper_bound(int arr[], int N, int X)
{
    // Stores minimum possible
    // value of the upper_bound
    int low = 0;
 
    // Stores maximum possible
    // value of the upper_bound
    int high = N;
 
    // Calculate the upper_bound
    // of X using binary search
    while (low < high) {
 
        // Stores mid element
        // of low and high
        int mid = low + (high - low) / 2;
 
        // If X is greater than
        // or equal  to arr[mid]
        if (X >= arr[mid]) {
 
            // Find upper_bound in
            // right subarray
            low = mid + 1;
        }
 
        // If X is less than arr[mid]
        else {
 
            // Find upper_bound in
            // left subarray
            high = mid;
        }
    }
 
    // Return the upper_bound index
    return low;
}
 
// Function to find the frequency
// of an element in the array
int findFreq(int arr[], int N,
             int X)
{
    // Stores upper_bound index of X
    int UB = upper_bound(arr, N, X);
 
    // Stores lower_bound index of X
    int LB = lower_bound(arr, N, X);
 
    return (UB - LB);
}
 
// Utility function to print the frequency
// of each distinct element of the array
void UtilFindFreqArr(int arr[], int N)
{
    // Sort the array in
    // ascending order
    qsort(arr, N,
          sizeof(int), cmp);
 
    // Print start bracket
    printf("{ ");
 
    // Traverse the array
    for (int i = 0; i < N;) {
 
        // Stores frequency
        // of arr[i];
        int fr = findFreq(arr, N,
                          arr[i]);
 
        // Print frequency of arr[i]
        printf("%d : %d",
               arr[i], fr);
 
        // Update i
        i++;
 
        // Remove duplicate elements
        // from the array
        while (i < N && arr[i] == arr[i - 1]) {
 
            // Update i
            i++;
        }
 
        // If arr[i] is not
        // the last array element
        if (i <= N - 1) {
 
            printf(", ");
        }
    }
 
    // Print end bracket
    printf(" }");
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 100000000, 3,
                  100000000, 3 };
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    UtilFindFreqArr(arr, N);
}
Output: 
{ 1 : 1, 3 : 2, 100000000 : 2 }

 

Time Complexity: O(N * log(N)) 
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :