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[] 

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 :

4

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;
}


Output :

4

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.



My Personal Notes arrow_drop_up

Improved By : Sam007


 

Recommended Posts:



2.5 Average Difficulty : 2.5/5.0
Based on 176 vote(s)






User Actions