# Count frequency of number in sorted array Problem

Problem: Given a sorted array, We have to count the frequency of number i.e. the count number of occurrences of a number in the given sorted array.

Example**:**

Arr[]={ 5,10,15,15,15,25,30,60,80 } ,p= 15

Output : 3

Explanation: Number 15 occurs 3 times in the sorted array.

This problem can be done in two ways:-

1. Linear Search
2. Binary Search

### # Approach 1

In linear search we compare each element with the element to be found as we traverse through the array.

Code (Linear Search):

``````#include <iostream>
using namespace std;

// Function returns number of times p occurs in array
int countrepeat(int array[], int size, int p)
{
int ans = 0;
for (int i = 0; i < size; i++)
if (array[i] == p)
ans++;
return ans;
}

// Driver code
int main()
{
int array[] = { 32, 32, 54, 65, 78, 78, 78, 78, 85 };
int size = sizeof(array) / sizeof(array);
int p = 78;
cout << p << " is repeated " << countrepeat(array, size, p) << " times";
return 0;
}

``````

Output

``````78 is repeated 4 times

``````

Time Complexity:  O(n)

### # Approach 2

In binary search, we find the middle element ((start+last)/2) (Here, start corresponds to first element and last corresponds to the last element) and check if the element to be found is smaller or greater than value present at the middle.

If the element to be found is greater then we initialize the start value as mid+1 else last is initialized as mid-1.

Code (Binary Search):

``````#include <iostream>
using namespace std;

// C++ program to count occurrences of an element

//function returns the position of p in given array
int binarysrch(int array[], int l, int r, int p)
{
if (r < l)
return -1;

int mid = l + (r - l) / 2;

// If element is found at the middle
if (array[mid] == p)
return mid;

// If element is smaller than mid, then
// it can only be there in left subarray
if (array[mid] > p)
return binarysrch(array, l, mid - 1, p);

// Else the element can only be there
// in right subarray
return binarysrch(array, mid + 1, r, p);
}

// function returns number of times p occurs in array
int countrepeat(int array[], int size, int p)
{
int token = binarysrch(array, 0, size - 1, p);

if (token == -1)
return 0;

// Counting elements on left
int count = 1;
int left = token - 1;

while (left >= 0 && array[left] == p)
count++, left--;

// Counting elements on right
int right = token + 1;
while (right < size && array[right] == p)
count++, right++;

return count;
}

// Driver code
int main()
{
int array[] = { 1, 12, 15, 15, 15, 30, 45, 76, 80 };
int size = sizeof(array) / sizeof(array);
int p = 15;
cout << countrepeat(array, size, p);
return 0;
}

``````

Output

``````3

``````

Time Complexity : O(log n + count) where count is number of occurrences.