Count number of occurrences (or frequency) in a sorted array

Given a sorted array arr[] and a number x, write a function that counts the occurrences of x in arr[]. Expected time complexity is O(Logn)

Examples:

  Input: arr[] = {1, 1, 2, 2, 2, 2, 3,},   x = 2
  Output: 4 // x (or 2) occurs 4 times in arr[]

  Input: arr[] = {1, 1, 2, 2, 2, 2, 3,},   x = 3
  Output: 1 

  Input: arr[] = {1, 1, 2, 2, 2, 2, 3,},   x = 1
  Output: 2 

  Input: arr[] = {1, 1, 2, 2, 2, 2, 3,},   x = 4
  Output: -1 // 4 doesn't occur in arr[]

Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Method 1 (Linear Search)
Linearly search for x, count the occurrences of x and return the count.

C++

// C++ program to count occurrences of an element 
#include<bits/stdc++.h> 
using namespace std; 
  
// Returns number of times x occurs in arr[0..n-1] 
int countOccurrences(int arr[], int n, int x) 
{ 
    int res = 0; 
    for (int i=0; i<n; i++) 
        if (x == arr[i]) 
          res++; 
    return res; 
} 
  
// Driver code 
int main() 
{ 
    int arr[] = {1, 2, 2, 2, 2, 3, 4, 7 ,8 ,8 }; 
    int n = sizeof(arr)/sizeof(arr[0]); 
    int x = 2; 
    cout << countOccurrences(arr, n, x); 
    return 0; 
} 

Java

// Java program to count occurrences  
// of an element 
  
class Main 
{ 
    // Returns number of times x occurs in arr[0..n-1] 
    static int countOccurrences(int arr[], int n, int x) 
    { 
        int res = 0; 
        for (int i=0; i<n; i++) 
            if (x == arr[i]) 
              res++; 
        return res; 
    } 
      
    public static void main(String args[]) 
    { 
        int arr[] = {1, 2, 2, 2, 2, 3, 4, 7 ,8 ,8 }; 
        int n = arr.length; 
        int x = 2; 
        System.out.println(countOccurrences(arr, n, x)); 
    } 
} 

Python3

# Python3 program to count  
# occurrences of an element 
  
# Returns number of times x  
# occurs in arr[0..n-1] 
def countOccurrences(arr, n, x): 
    res = 0
    for i in range(n): 
        if x == arr[i]: 
            res += 1
    return res 
   
# Driver code 
arr = [1, 2, 2, 2, 2, 3, 4, 7 ,8 ,8] 
n = len(arr) 
x = 2
print (countOccurrences(arr, n, x)) 

C#

// C# program to count occurrences  
// of an element 
using System; 
  
class GFG 
{ 
    // Returns number of times x 
    // occurs in arr[0..n-1] 
    static int countOccurrences(int []arr, 
                                int n, int x) 
    { 
        int res = 0; 
          
        for (int i = 0; i < n; i++) 
            if (x == arr[i]) 
            res++; 
              
        return res; 
    } 
      
    // driver code     
    public static void Main() 
    { 
        int []arr = {1, 2, 2, 2, 2, 3, 4, 7 ,8 ,8 }; 
        int n = arr.Length; 
        int x = 2; 
          
        Console.Write(countOccurrences(arr, n, x)); 
    } 
} 
  
// This code is contributed by Sam007 

PHP

<?php 
// PHP program to count occurrences 
// of an element 
  
// Returns number of times x  
// occurs in arr[0..n-1] 
function countOccurrences($arr, $n, $x) 
{ 
    $res = 0; 
    for ($i = 0; $i < $n; $i++) 
        if ($x == $arr[$i]) 
        $res++; 
    return $res; 
} 
  
    // Driver code 
    $arr = array(1, 2, 2, 2, 2, 3, 4, 7 ,8 ,8 ); 
    $n = count($arr); 
    $x = 2; 
    echo countOccurrences($arr,$n, $x); 
      
// This code is contributed by Sam007 
?> 

Output :

Time Complexity: O(n)

Method 2 (Better using Binary Search)
We first find an occurrence using binary search. Then we match toward left and right sides of the matched the found index.

C++

// C++ program to count occurrences of an element 
#include <bits/stdc++.h> 
using namespace std; 
  
// A recursive binary search function. It returns 
// location of x in given array arr[l..r] is present, 
// otherwise -1 
int binarySearch(int arr[], int l, int r, int x) 
{ 
    if (r < l) 
        return -1; 
  
    int mid = l + (r - l) / 2; 
  
    // If the element is present at the middle 
    // itself 
    if (arr[mid] == x) 
        return mid; 
  
    // If element is smaller than mid, then 
    // it can only be present in left subarray 
    if (arr[mid] > x) 
        return binarySearch(arr, l, mid - 1, x); 
  
    // Else the element can only be present 
    // in right subarray 
    return binarySearch(arr, mid + 1, r, x); 
} 
  
// Returns number of times x occurs in arr[0..n-1] 
int countOccurrences(int arr[], int n, int x) 
{ 
    int ind = binarySearch(arr, 0, n - 1, x); 
  
    // If element is not present 
    if (ind == -1) 
        return 0; 
  
    // Count elements on left side. 
    int count = 1; 
    int left = ind - 1; 
    while (left >= 0 && arr[left] == x) 
        count++, left--; 
  
    // Count elements on right side. 
    int right = ind + 1; 
    while (right < n && arr[right] == x) 
        count++, right++; 
  
    return count; 
} 
  
// Driver code 
int main() 
{ 
    int arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 }; 
    int n = sizeof(arr) / sizeof(arr[0]); 
    int x = 2; 
    cout << countOccurrences(arr, n, x); 
    return 0; 
}

Java

// Java program to count  
// occurrences of an element 
class GFG  
{ 
  
    // A recursive binary search  
    // function. It returns location  
    // of x in given array arr[l..r]  
    // is present, otherwise -1 
    static int binarySearch(int arr[], int l, 
                            int r, int x) 
    { 
        if (r < l) 
            return -1; 
  
        int mid = l + (r - l) / 2; 
  
        // If the element is present  
        // at the middle itself 
        if (arr[mid] == x) 
            return mid; 
  
        // If element is smaller than  
        // mid, then it can only be  
        // present in left subarray 
        if (arr[mid] > x) 
            return binarySearch(arr, l,  
                                mid - 1, x); 
  
        // Else the element can 
        // only be present in 
        // right subarray 
        return binarySearch(arr, mid + 1, r, x); 
    } 
  
    // Returns number of times x 
    // occurs in arr[0..n-1] 
    static int countOccurrences(int arr[],  
                                int n, int x) 
    { 
        int ind = binarySearch(arr, 0,  
                               n - 1, x); 
  
        // If element is not present 
        if (ind == -1) 
            return 0; 
  
        // Count elements on left side. 
        int count = 1; 
        int left = ind - 1; 
        while (left >= 0 &&  
               arr[left] == x) 
        { 
            count++; 
            left--; 
        } 
  
        // Count elements  
        // on right side. 
        int right = ind + 1; 
        while (right < n &&  
               arr[right] == x) 
        { 
            count++; 
            right++; 
        } 
  
        return count; 
    } 
  
  
    // Driver code 
    public static void main(String[] args)  
    { 
        int arr[] = {1, 2, 2, 2, 2,  
                     3, 4, 7, 8, 8}; 
        int n = arr.length; 
        int x = 2; 
        System.out.print(countOccurrences(arr, n, x)); 
    } 
} 
  
// This code is contributed  
// by ChitraNayal 

Python 3

# Python 3 program to count  
# occurrences of an element 
  
# A recursive binary search  
# function. It returns location 
# of x in given array arr[l..r]  
# is present, otherwise -1 
def binarySearch(arr, l, r, x): 
    if (r < l): 
        return -1
  
    mid = int( l + (r - l) / 2) 
  
    # If the element is present  
    # at the middle itself 
    if arr[mid] == x: 
        return mid 
  
    # If element is smaller than  
    # mid, then it can only be 
    # present in left subarray 
    if arr[mid] > x: 
        return binarySearch(arr, l,  
                            mid - 1, x) 
  
    # Else the element  
    # can only be present 
    # in right subarray 
    return binarySearch(arr, mid + 1, 
                                r, x) 
  
# Returns number of times  
# x occurs in arr[0..n-1] 
def countOccurrences(arr, n, x): 
    ind = binarySearch(arr, 0, n - 1, x) 
  
    # If element is not present 
    if ind == -1: 
        return 0
  
    # Count elements  
    # on left side. 
    count = 1
    left = ind - 1
    while (left >= 0 and 
           arr[left] == x): 
        count += 1
        left -= 1
  
    # Count elements on 
    # right side. 
    right = ind + 1; 
    while (right < n and
           arr[right] == x): 
        count += 1
        right += 1
  
    return count 
  
# Driver code 
arr = [ 1, 2, 2, 2, 2,  
        3, 4, 7, 8, 8 ] 
n = len(arr) 
x = 2
print(countOccurrences(arr, n, x)) 
  
# This code is contributed  
# by ChitraNayal 

C#

// C# program to count  
// occurrences of an element 
using System; 
  
class GFG  
{ 
  
    // A recursive binary search  
    // function. It returns location 
    // of x in given array arr[l..r]  
    // is present, otherwise -1 
    static int binarySearch(int[] arr, int l,  
                            int r, int x) 
    { 
        if (r < l) 
            return -1; 
  
        int mid = l + (r - l) / 2; 
  
        // If the element is present  
        // at the middle itself 
        if (arr[mid] == x) 
            return mid; 
  
        // If element is smaller than  
        // mid, then it can only be  
        // present in left subarray 
        if (arr[mid] > x) 
            return binarySearch(arr, l,  
                                mid - 1, x); 
  
        // Else the element  
        // can only be present 
        // in right subarray 
        return binarySearch(arr, mid + 1, 
                                   r, x); 
    } 
  
    // Returns number of times x  
    // occurs in arr[0..n-1] 
    static int countOccurrences(int[] arr,  
                                int n, int x) 
    { 
        int ind = binarySearch(arr, 0,  
                               n - 1, x); 
  
        // If element is not present 
        if (ind == -1) 
            return 0; 
  
        // Count elements on left side. 
        int count = 1; 
        int left = ind - 1; 
        while (left >= 0 &&  
               arr[left] == x) 
        { 
            count++; 
            left--; 
        } 
  
        // Count elements on right side. 
        int right = ind + 1; 
        while (right < n &&  
               arr[right] == x) 
        { 
            count++; 
            right++; 
        } 
  
        return count; 
    } 
  
  
    // Driver code 
    public static void Main()  
    { 
        int[] arr = {1, 2, 2, 2, 2,  
                     3, 4, 7, 8, 8}; 
        int n = arr.Length; 
        int x = 2; 
        Console.Write(countOccurrences(arr, n, x)); 
    } 
} 
  
// This code is contributed  
// by ChitraNayal 

PHP

<?php  
// PHP program to count  
// occurrences of an element 
  
// A recursive binary search  
// function. It returns location 
// of x in given array arr[l..r]  
// is present, otherwise -1 
function binarySearch(&$arr, $l,  
                         $r, $x) 
{ 
    if ($r < $l) 
        return -1; 
  
    $mid = $l + ($r - $l) / 2; 
  
    // If the element is present  
    // at the middle itself 
    if ($arr[$mid] == $x) 
        return $mid; 
  
    // If element is smaller than  
    // mid, then it can only be 
    // present in left subarray 
    if ($arr[$mid] > $x) 
        return binarySearch($arr, $l,    
                            $mid - 1, $x); 
  
    // Else the element 
    // can only be present 
    // in right subarray 
    return binarySearch($arr, $mid + 1,  
                                $r, $x); 
} 
  
// Returns number of times 
// x occurs in arr[0..n-1] 
function countOccurrences($arr, $n, $x) 
{ 
    $ind = binarySearch($arr, 0,  
                        $n - 1, $x); 
  
    // If element is not present 
    if ($ind == -1) 
        return 0; 
  
    // Count elements  
    // on left side. 
    $count = 1; 
    $left = $ind - 1; 
    while ($left >= 0 &&  
           $arr[$left] == $x) 
    {  
        $count++; 
        $left--; 
    } 
      
    // Count elements on right side. 
    $right = $ind + 1; 
    while ($right < $n &&  
           $arr[$right] == $x) 
    { 
        $count++; 
        $right++; 
    } 
    return $count; 
} 
  
// Driver code 
$arr = array( 1, 2, 2, 2, 2,  
              3, 4, 7, 8, 8 ); 
$n = sizeof($arr); 
$x = 2; 
echo countOccurrences($arr, $n, $x); 
  
// This code is contributed 
// by ChitraNayal 
?> 

Output :

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

Method 3 (Best using Improved Binary Search)
1) Use Binary search to get index of the first occurrence of x in arr[]. Let the index of the first occurrence be i.
2) Use Binary search to get index of the last occurrence of x in arr[]. Let the index of the last occurrence be j.
3) Return (j – i + 1);

C++

// C++ program to count occurrences of an element 
// in a sorted array. 
# include <bits/stdc++.h> 
using namespace std; 
  
/* if x is present in arr[] then returns the count 
    of occurrences of x, otherwise returns 0. */
int count(int arr[], int x, int n) 
{     
  /* get the index of first occurrence of x */
  int *low = lower_bound(arr, arr+n, x); 
  
  // If element is not present, return 0 
  if (low == (arr + n) || *low != x) 
     return 0; 
     
  /* Else get the index of last occurrence of x. 
     Note that we  are only looking in the  
     subarray after first occurrence */   
  int *high = upper_bound(low, arr+n, x);      
     
  /* return count */
  return high - low; 
} 
  
/* driver program to test above functions */
int main() 
{ 
  int arr[] = {1, 2, 2, 3, 3, 3, 3}; 
  int x =  3;  // Element to be counted in arr[] 
  int n = sizeof(arr)/sizeof(arr[0]); 
  int c = count(arr, x, n); 
  printf(" %d occurs %d times ", x, c); 
  return 0; 
} 

C

# include <stdio.h> 
  
/* if x is present in arr[] then returns  
   the index of FIRST occurrence  
   of x in arr[0..n-1], otherwise returns -1 */
int first(int arr[], int low, int high, int x, int n) 
{ 
  if(high >= low) 
  { 
    int mid = (low + high)/2;  /*low + (high - low)/2;*/
    if( ( mid == 0 || x > arr[mid-1]) && arr[mid] == x) 
      return mid; 
    else if(x > arr[mid]) 
      return first(arr, (mid + 1), high, x, n); 
    else
      return first(arr, low, (mid -1), x, n); 
  } 
  return -1; 
} 
  
/* if x is present in arr[] then returns the 
   index of LAST occurrence of x in arr[0..n-1],  
   otherwise returns -1 */ 
int last(int arr[], int low, int high, int x, int n) 
{ 
  if (high >= low) 
  { 
    int mid = (low + high)/2;  /*low + (high - low)/2;*/
    if( ( mid == n-1 || x < arr[mid+1]) && arr[mid] == x ) 
      return mid; 
    else if(x < arr[mid]) 
      return last(arr, low, (mid -1), x, n); 
    else
      return last(arr, (mid + 1), high, x, n);       
  } 
  return -1; 
} 
  
/* if x is present in arr[] then returns the count 
   of occurrences of x, otherwise returns -1. */
int count(int arr[], int x, int n) 
{ 
  int i; // index of first occurrence of x in arr[0..n-1] 
  int j; // index of last occurrence of x in arr[0..n-1] 
      
  /* get the index of first occurrence of x */
  i = first(arr, 0, n-1, x, n); 
  
  /* If x doesn't exist in arr[] then return -1 */
  if(i == -1) 
    return i; 
     
  /* Else get the index of last occurrence of x.  
     Note that we are only looking in the subarray  
     after first occurrence */   
  j = last(arr, i, n-1, x, n);      
     
  /* return count */
  return j-i+1; 
} 
  
/* driver program to test above functions */
int main() 
{ 
  int arr[] = {1, 2, 2, 3, 3, 3, 3}; 
  int x =  3;  // Element to be counted in arr[] 
  int n = sizeof(arr)/sizeof(arr[0]); 
  int c = count(arr, x, n); 
  printf(" %d occurs %d times ", x, c); 
  getchar(); 
  return 0; 
} 

Java

// Java program to count occurrences  
// of an element 
  
class Main 
{ 
    /* if x is present in arr[] then returns  
       the count of occurrences of x,  
       otherwise returns -1. */
    static int count(int arr[], int x, int n) 
    { 
      // index of first occurrence of x in arr[0..n-1]     
      int i;  
        
      // index of last occurrence of x in arr[0..n-1] 
      int j;  
           
      /* get the index of first occurrence of x */
      i = first(arr, 0, n-1, x, n); 
       
      /* If x doesn't exist in arr[] then return -1 */
      if(i == -1) 
        return i; 
          
      /* Else get the index of last occurrence of x.  
         Note that we are only looking in the  
         subarray after first occurrence */  
      j = last(arr, i, n-1, x, n);      
          
      /* return count */
      return j-i+1; 
    } 
       
    /* if x is present in arr[] then returns the  
       index of FIRST occurrence of x in arr[0..n-1],  
       otherwise returns -1 */
    static int first(int arr[], int low, int high, int x, int n) 
    { 
      if(high >= low) 
      { 
        /*low + (high - low)/2;*/  
        int mid = (low + high)/2;   
        if( ( mid == 0 || x > arr[mid-1]) && arr[mid] == x) 
          return mid; 
        else if(x > arr[mid]) 
          return first(arr, (mid + 1), high, x, n); 
        else
          return first(arr, low, (mid -1), x, n); 
      } 
      return -1; 
    } 
       
    /* if x is present in arr[] then returns the  
       index of LAST occurrence of x in arr[0..n-1],  
       otherwise returns -1 */
    static int last(int arr[], int low, int high, int x, int n) 
    { 
      if(high >= low) 
      { 
        /*low + (high - low)/2;*/      
        int mid = (low + high)/2;  
        if( ( mid == n-1 || x < arr[mid+1]) && arr[mid] == x ) 
          return mid; 
        else if(x < arr[mid]) 
          return last(arr, low, (mid -1), x, n); 
        else
          return last(arr, (mid + 1), high, x, n);       
      } 
      return -1; 
    } 
       
    public static void main(String args[]) 
    { 
        int arr[] = {1, 2, 2, 3, 3, 3, 3}; 
          
        // Element to be counted in arr[] 
        int x =  3;  
        int n = arr.length; 
        int c = count(arr, x, n); 
        System.out.println(x+" occurs "+c+" times"); 
    } 
} 

Python3

# Python3 program to count 
# occurrences of an element 
  
# if x is present in arr[] then  
# returns the count of occurrences 
# of x, otherwise returns -1.  
def count(arr, x, n): 
  
    # get the index of first 
    # occurrence of x  
    i = first(arr, 0, n-1, x, n) 
   
    # If x doesn't exist in  
    # arr[] then return -1  
    if i == -1: 
        return i 
      
    # Else get the index of last occurrence 
    # of x. Note that we are only looking 
    # in the subarray after first occurrence    
    j = last(arr, i, n-1, x, n);      
      
    # return count  
    return j-i+1; 
  
# if x is present in arr[] then return 
# the index of FIRST occurrence of x in 
# arr[0..n-1], otherwise returns -1  
def first(arr, low, high, x, n): 
    if high >= low: 
  
        # low + (high - low)/2 
        mid = (low + high)//2      
          
    if (mid == 0 or x > arr[mid-1]) and arr[mid] == x: 
        return mid 
    elif x > arr[mid]: 
        return first(arr, (mid + 1), high, x, n) 
    else: 
        return first(arr, low, (mid -1), x, n) 
    return -1; 
   
# if x is present in arr[] then return 
# the index of LAST occurrence of x  
# in arr[0..n-1], otherwise returns -1  
def last(arr, low, high, x, n): 
    if high >= low: 
  
        # low + (high - low)/2 
        mid = (low + high)//2;  
   
    if(mid == n-1 or x < arr[mid+1]) and arr[mid] == x : 
        return mid 
    elif x < arr[mid]: 
        return last(arr, low, (mid -1), x, n) 
    else: 
        return last(arr, (mid + 1), high, x, n)      
    return -1
  
# driver program to test above functions  
arr = [1, 2, 2, 3, 3, 3, 3] 
x = 3  # Element to be counted in arr[] 
n = len(arr) 
c = count(arr, x, n) 
print ("%d occurs %d times "%(x, c)) 

C#

// C# program to count occurrences  
// of an element 
using System; 
  
class GFG 
{ 
      
    /* if x is present in arr[] then returns  
    the count of occurrences of x,  
    otherwise returns -1. */
    static int count(int []arr, int x, int n) 
    { 
    // index of first occurrence of x in arr[0..n-1]  
    int i;  
          
    // index of last occurrence of x in arr[0..n-1] 
    int j;  
          
    /* get the index of first occurrence of x */
    i = first(arr, 0, n-1, x, n); 
      
    /* If x doesn't exist in arr[] then return -1 */
    if(i == -1) 
        return i; 
          
    /* Else get the index of last occurrence of x.  
        Note that we are only looking in the  
        subarray after first occurrence */
    j = last(arr, i, n-1, x, n);      
          
    /* return count */
    return j-i+1; 
    } 
      
    /* if x is present in arr[] then returns the  
    index of FIRST occurrence of x in arr[0..n-1],  
    otherwise returns -1 */
    static int first(int []arr, int low, int high,  
                                     int x, int n) 
    { 
    if(high >= low) 
    { 
        /*low + (high - low)/2;*/
        int mid = (low + high)/2;  
        if( ( mid == 0 || x > arr[mid-1])  
                            && arr[mid] == x) 
        return mid; 
        else if(x > arr[mid]) 
        return first(arr, (mid + 1), high, x, n); 
        else
        return first(arr, low, (mid -1), x, n); 
    } 
    return -1; 
    } 
      
    /* if x is present in arr[] then returns the  
    index of LAST occurrence of x in arr[0..n-1],  
    otherwise returns -1 */
    static int last(int []arr, int low, 
                        int high, int x, int n) 
    { 
    if(high >= low) 
    { 
        /*low + (high - low)/2;*/    
        int mid = (low + high)/2;  
        if( ( mid == n-1 || x < arr[mid+1]) 
                            && arr[mid] == x ) 
        return mid; 
        else if(x < arr[mid]) 
        return last(arr, low, (mid -1), x, n); 
        else
        return last(arr, (mid + 1), high, x, n);      
    } 
    return -1; 
    } 
      
    public static void Main() 
    { 
        int []arr = {1, 2, 2, 3, 3, 3, 3}; 
          
        // Element to be counted in arr[] 
        int x = 3;  
        int n = arr.Length; 
        int c = count(arr, x, n); 
          
        Console.Write(x + " occurs " + c + " times"); 
    } 
} 
// This code is contributed by Sam007 

Output:

3 occurs 4 times

Time Complexity: O(Logn)
Programming Paradigm: Divide & Conquer

Please write comments if you find the above codes/algorithms incorrect, or find other ways to solve the same problem.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes

Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

C++

Java

Python3

C#

PHP

C++

Java

Python 3

C#

PHP

C++

C

Java

Python3

C#

Recommended Posts: