Related Articles

# 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 ` `#include `   `// 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);`   `    ``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 :