Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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

  • Difficulty Level : Medium
  • Last Updated : 02 Dec, 2021
 

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: 

Become a success story instead of just reading about them. Prepare for coding interviews at Amazon and other top product-based companies with our Amazon Test Series. Includes topic-wise practice questions on all important DSA topics along with 10 practice contests of 2 hours each. Designed by industry experts that will surely help you practice and sharpen your programming skills. Wait no more, start your preparation today!

  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
?>

Javascript




<script>
 
// Javascript program to count occurrences
// of an element
 
 
    // Returns number of times x occurs in arr[0..n-1]
    function countOccurrences(arr,n,x)
    {
        let res = 0;
        for (let i=0; i<n; i++)
        {
            if (x == arr[i])
                res++;
        }
        return res;
    }
     
    arr=[1, 2, 2, 2, 2, 3, 4, 7 ,8 ,8]
    let  n = arr.length;
    let x = 2;
    document.write(countOccurrences(arr, n, x));
     
    // This code is contributed by avanitrachhadiya2155
     
</script>

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

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
?>

Javascript




<script>
 
// Javascript 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;
 
    var mid = l + parseInt((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)
{
    var ind = binarySearch(arr, 0, n - 1, x);
 
    // If element is not present
    if (ind == -1)
        return 0;
 
    // Count elements on left side.
    var count = 1;
    var left = ind - 1;
    while (left >= 0 && arr[left] == x)
        count++, left--;
 
    // Count elements on right side.
    var right = ind + 1;
    while (right < n && arr[right] == x)
        count++, right++;
 
    return count;
}
 
// Driver code
var arr = [ 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 ];
var n = arr.length;
var x = 2;
document.write(countOccurrences(arr, n, x));
 
// This code is contributed by noob2000.
</script>

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

Javascript




<script>
 
// Javascript program to count occurrences
// of an element
 
/* if x is present in arr[] then returns
the count of occurrences of x,
otherwise returns -1. */
function count(arr, x, n)
{
     
    // Index of first occurrence of x in arr[0..n-1]   
    let i;
     
    // Index of last occurrence of x in arr[0..n-1]
    let 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
function first(arr, low, high, x, n)
{
    if (high >= low)
    {
         
        // low + (high - low)/2;
        let 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
function last(arr, low, high, x, n)
{
    if (high >= low)
    {
        /*low + (high - low)/2;*/     
        let mid = Math.floor((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;
}
 
// Driver code
let arr = [ 1, 2, 2, 3, 3, 3, 3 ];
 
// Element to be counted in arr[]
let x =  3;
let n = arr.length;
let c = count(arr, x, n);
 
document.write(x + " occurs " + c + " times");
 
// This code is contributed by target_2
 
</script>

Output:  

3 occurs 4 times

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

Using Collections.frequency() method of java

Java




/*package whatever //do not write package name here */
import java.util.ArrayList;
import java.util.Collections;
 
public class GFG {
   
    // Function to count occurrences
    static int countOccurrences(ArrayList<Integer> clist,
                                int x)
    {
        // returning the frequency of
        // element x in the ArrayList
        // using Collections.frequency() method
        return Collections.frequency(clist, x);
    }
 
    // Driver Code
    public static void main(String args[])
    {
        int arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
        int x = 2;
        ArrayList<Integer> clist = new ArrayList<>();
 
        // adding elements of array to
        // ArrayList
        for (int i : arr)
            clist.add(i);
 
        // displaying the frequency of x in ArrayList
        System.out.println(x + " occurs "
                           + countOccurrences(clist, x)
                           + " times");
    }
}

C#




// C# program for the above approach
using System;
 
public class GFG
{
 
    // Function to count occurrences
    static int countOccurrences(int[] arr,
                                int x)
    {
        int count = 0;
        int n = arr.Length;
        for (int i=0; i < n; i++)
        if (arr[i] == x)
            count++;
        return count;
    }   
   
    // Driver Code
    public static void Main (string[] args)
    {
        int[] arr = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
        int x = 2;
  
        // displaying the frequency of x in ArrayList
        Console.WriteLine(x + " occurs "
                           + countOccurrences(arr, x)
                           + " times");
  
    }
}
 
// This code is contributed by avijitmondal1998.

Javascript




<script>
 
// javascript program for above approach
 
    // Function to count occurrences
    function countOccurrences(arr, x)
    {
        let count = 0;
        let n = arr.length;
        for (let i=0; i < n; i++)
        if (arr[i] == x)
            count++;
        return count;
    }   
   
// Driver Code
    let arr = [ 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 ];
    let x = 2;
  
    // displaying the frequency of x in ArrayList
    document.write(x + " occurs "
                     + countOccurrences(arr, x)
                        + " times");
 
// This code is contributed by splevel62.
</script>

Output:

2 occurs 4 times

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
Recommended Articles
Page :

Start Your Coding Journey Now!