# 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 Practice

### Method 1 (Linear Search)

Linearly search for x, count the occurrences of x and return the count.

## C++

 `#include ` `// 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;``    ``printf``(``"%d"``, countOccurrences(arr, n, x));``    ``return` `0;``}`

## C

 `#include ` `int` `main() {` `    ``// code``    ``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

## 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`

## Javascript

 ``

## PHP

 ``

Output :

`4`

Time Complexity: O(n)
Space Complexity: O(1), as no extra space is used

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

## C

 `#include ` `// A recursive binary search function. It returns``// location of x in given array arr[l..r] if 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 the left subarray``    ``if` `(arr[mid] > x)``        ``return` `binarySearch(arr, l, mid - 1, x);` `    ``// Else the element can only be present``    ``// in the 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 the element is not present``    ``if` `(ind == -1)``        ``return` `0;` `    ``// Count elements on the left side``    ``int` `count = 1;``    ``int` `left = ind - 1;``    ``while` `(left >= 0 && arr[left] == x)``    ``{``        ``count++;``        ``left--;``    ``}` `    ``// Count elements on the 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;``    ``printf``(``"%d"``, 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`

## Javascript

 ``

## PHP

 ` ``\$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 :

`4`

Time Complexity : O(Log n + count) where count is number of occurrences.
Space Complexity: O(logn), due to recursive stack space

### 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 ``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 ` `/* 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

 ``

Output:

`3 occurs 4 times`

Time Complexity: O(Logn)

Auxiliary Space: O(1), as no extra space is used

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to count occurrences``int` `countOccurrences(``int` `arr[],``                        ``int` `x, ``int` `N)``{``    ``int` `count = 0;``    ``for` `(``int` `i=0; i < N; i++)``        ``if` `(arr[i] == x)``            ``count++;``    ``return` `count;``} ` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };``    ``int` `x = 2;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);`` ` `    ``// displaying the frequency of x in ArrayList``    ``cout <

## 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 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 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"``);``    ``}``}`

## Python3

 `# Python code to implement the approach` `# Function to count occurrences``def` `countOccurrences(arr, x) :` `    ``count ``=` `0``    ``n ``=` `len``(arr)``    ``for` `i ``in` `range``(n) :``        ``if` `(arr[i] ``=``=` `x):``            ``count ``+``=` `1``            ` `    ``return` `count``   ` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``        ` `    ``arr ``=` `[ ``1``, ``2``, ``2``, ``2``, ``2``, ``3``, ``4``, ``7``, ``8``, ``8` `]``    ``x ``=` `2``  ` `    ``# displaying the frequency of x in ArrayList``    ``print``(x , ``"occurs"``                        ``, countOccurrences(arr, x)``                        ``, ``"times"``)``    ` `    ``# This code is contributed by sanjoy_62.`

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

 ``

Output:

`2 occurs 4 times`

Time Complexity: O(n)
Auxiliary Space: O(1), as no extra space is used

### Method 5: Using Hashing

We can also use hashing method to count occurrences (or frequency) of a specific element in a sorted array.

#### Steps:

We use following steps to find occurrence-

1. First we create an unsorted_map to store elements with their frequency.
2. Now we iterate through the array and store its elements inside the map.
3. Then by using map.find() function, we can easily find the occurrences (or frequency) of any element.

Below is the implementation:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to count occurrences``int` `countOccurrences(``int` `arr[], ``int` `x, ``int` `N)``{``    ``unordered_map<``int``, ``int``> mp;``    ``for` `(``int` `i = 0; i < N; i++) {``        ``mp[arr[i]]++;``    ``}``    ``if` `(mp.find(x) == mp.end())``        ``return` `0;``    ``auto` `it = mp.find(x);``    ``return` `it->second;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };``    ``int` `x = 2;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// displaying the frequency of x in Array``    ``cout << x << ``" occurs "` `<< countOccurrences(arr, x, N)``         ``<< ``" times"``;``    ``return` `0;``}` `// This code is contributed by Susobhan Akhuli`

## Java

 `// Java program for the above approach``import` `java.util.HashMap;``import` `java.util.Map;` `public` `class` `Main ``{` `  ``// Function to count occurrences``  ``static` `int` `countOccurrences(``int``[] arr, ``int` `x, ``int` `N)``  ``{``    ``Map mp``      ``= ``new` `HashMap();``    ``for` `(``int` `i = ``0``; i < N; i++) {``      ``mp.put(arr[i], mp.getOrDefault(arr[i], ``0``) + ``1``);``    ``}``    ``if` `(!mp.containsKey(x))``      ``return` `0``;``    ``return` `mp.get(x);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int``[] arr = { ``1``, ``2``, ``2``, ``2``, ``2``, ``3``, ``4``, ``7``, ``8``, ``8` `};``    ``int` `x = ``2``;``    ``int` `N = arr.length;` `    ``// displaying the frequency of x in Array``    ``System.out.println(x + ``" occurs "``                       ``+ countOccurrences(arr, x, N)``                       ``+ ``" times"``);``  ``}``}` `// This code is contributed by Susobhan Akhuli`

## Python3

 `# Python program for the above approach` `# Function to count occurrences``def` `countOccurrences(arr, x, N):``    ``mp ``=` `{}``    ``for` `i ``in` `range``(N):``        ``if` `arr[i] ``in` `mp:``            ``mp[arr[i]] ``+``=` `1``        ``else``:``            ``mp[arr[i]] ``=` `1` `    ``if` `x ``not` `in` `mp:``        ``return` `0` `    ``return` `mp[x]` `# Driver Code``arr ``=` `[``1``, ``2``, ``2``, ``2``, ``2``, ``3``, ``4``, ``7``, ``8``, ``8``]``x ``=` `2``N ``=` `len``(arr)` `# displaying the frequency of x in Array``print``(x, ``"occurs"``, countOccurrences(arr, x, N), ``"times"``)` `# This code is contributed by Susobhan Akhuli`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `Program {``    ``// Function to count occurrences``    ``static` `int` `CountOccurrences(``int``[] arr, ``int` `x)``    ``{``        ``Dictionary<``int``, ``int``> frequencyMap``            ``= ``new` `Dictionary<``int``, ``int``>();` `        ``// Count occurrences and store in the dictionary``        ``foreach``(``int` `num ``in` `arr)``        ``{``            ``if` `(frequencyMap.ContainsKey(num))``                ``frequencyMap[num]++;``            ``else``                ``frequencyMap[num] = 1;``        ``}` `        ``// Check if x exists in the dictionary, return its``        ``// frequency, or 0 if not found``        ``int` `frequency;``        ``if` `(frequencyMap.TryGetValue(x, ``out` `frequency))``            ``return` `frequency;``        ``else``            ``return` `0;``    ``}` `    ``// Driver Code``    ``static` `void` `Main()``    ``{``        ``int``[] arr = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };``        ``int` `x = 2;` `        ``// Display the frequency of x in the array``        ``Console.WriteLine(x + ``" occurs "``                          ``+ CountOccurrences(arr, x)``                          ``+ ``" times"``);``    ``}``}`

## Javascript

 `// JavaScript program for the above approach` `// Function to count occurrences``function` `countOccurrences(arr, x, N) ``{``      ``let mp = ``new` `Map();``      ``for` `(let i = 0; i < N; i++) {``           ``mp.set(arr[i], (mp.get(arr[i]) || 0) + 1);``       ``}``      ``if` `(!mp.has(x))``           ``return` `0;``      ``return` `mp.get(x);``}` `// Driver Code``let arr = [1, 2, 2, 2, 2, 3, 4, 7, 8, 8];``let x = 2;``let N = arr.length;` `// displaying the frequency of x in Array``console.log(x + ``" occurs "` `+ countOccurrences(arr, x,N) + ``" times"``);`

Output
```2 occurs 4 times

```

Time Complexity: O(N), where N is the number of elements in the array.
Auxiliary Space: O(K), where K is the number of unique elements in the array.

Another Approach:

• For the first occurrence, we will first find the index of the number and then search again in the left subarray as long as we are finding the number.
• For the last occurrence, we will first find the index of the number and then search again in the right subarray as long as we are finding the number

Follow the steps mentioned below to implement the idea:

• Create a function search(int[] nums, int target, boolean findStartIndex) to find the index value of target.
• And for first occurrence set firstIndex = search(arr, target, true) and last occurrence set lastIndex = search(arr, target, false) and these function do following things:

? Set ans = -1 , start = 0 , end = arr.length – 1 .

? Iterate a loop while start <= end , such as:

? Set mid = start + (end – start) / 2 .

? Check if target < arr[mid] ,then set end = mid – 1.

?  Else check if target > arr[mid], then set start = mid + 1.

? Otherwise , set ans = mid and check further such as

? If findStartIndex == true , then set end = mid – 1 .

? Else set start = mid + 1.

? Check if (firstIndex != -1 && lastIndex != -1 ) is true then return firstIndex- lastIndex +1 as the occurrences of x ,otherwise return 0.

Below is the implementation of the above approach:

## C++

 `#include ``#include ``using` `namespace` `std;` `int` `search(vector<``int``>& nums, ``int` `target, ``bool` `findStartIndex)``{``    ``int` `answer = -1;``    ``int` `start = 0;``    ``int` `end = nums.size() - 1;``    ``while` `(start <= end) {``        ``int` `mid = start + (end - start) / 2;``        ``if` `(target < nums[mid]) {``            ``end = mid - 1;``        ``}``        ``else` `if` `(target > nums[mid]) {``            ``start = mid + 1;``        ``}``        ``else` `{``            ``answer = mid;``            ``if` `(findStartIndex) {``                ``end = mid - 1;``            ``}``            ``else` `{``                ``start = mid + 1;``            ``}``        ``}``    ``}``    ``return` `answer;``}` `int` `countOccurrences(vector<``int``>& nums, ``int` `x)``{``    ``int` `firstIndex = search(nums, x, ``true``);``    ``int` `lastIndex = search(nums, x, ``false``);``    ``if` `(firstIndex != -1 && lastIndex != -1)``        ``return` `lastIndex - firstIndex + 1;``    ``else``        ``return` `0;``}` `int` `main()``{``    ``vector<``int``> arr{ 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };``    ``int` `x = 2;``    ``int` `c = countOccurrences(arr, x);``    ``cout << x << ``" occurs "` `<< c << ``" times"` `<< endl;``    ``return` `0;``}`

## C

 `#include ` `// Returns the index of the first occurrence``// or last occurrence of target in nums[]``int` `search(``int` `nums[], ``int` `target, ``int` `findStartIndex, ``int` `length)``{``    ``int` `answer = -1;``    ``int` `start = 0;``    ``int` `end = length - 1;``    ``while` `(start <= end) {``        ``int` `mid = start + (end - start) / 2;``        ``if` `(target < nums[mid]) {``            ``end = mid - 1;``        ``}``        ``else` `if` `(target > nums[mid]) {``            ``start = mid + 1;``        ``}``        ``else` `{``            ``answer = mid;``            ``if` `(findStartIndex) {``                ``end = mid - 1;``            ``}``            ``else` `{``                ``start = mid + 1;``            ``}``        ``}``    ``}``    ``return` `answer;``}` `// Returns the count of occurrences of x in arr[]``int` `countOccurrences(``int` `arr[], ``int` `length, ``int` `x)``{``    ``int` `firstIndex = search(arr, x, 1, length);``    ``int` `lastIndex = search(arr, x, 0, length);``    ``if` `(firstIndex != -1 && lastIndex != -1)``        ``return` `lastIndex - firstIndex + 1;``    ``else``        ``return` `0;``}` `// 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;``    ``int` `c = countOccurrences(arr, n, x);``    ``printf``(``"%d occurs %d times\n"``, x, c);``    ``return` `0;``}`

## Java

 `// Java program to count occurrences``// of an element``import` `java.util.*;``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` `firstIndex = search(arr, x, ``true``);``        ``int` `lastIndex = search(arr, x, ``false``);``        ``if` `(firstIndex != -``1` `&& lastIndex != -``1``)``            ``return` `lastIndex - firstIndex + ``1``;``        ``else``            ``return` `0``;``    ``}` `    ``// if target is present in arr[] then``    ``// returns the index of FIRST``    ``// occurrence and last occurrence of target in``    ``// arr[0..n-1], otherwise returns -1``    ``static` `int` `search(``int``[] nums, ``int` `target,``                      ``boolean` `findStartIndex)``    ``{``        ``int` `ans = -``1``;``        ``int` `start = ``0``;``        ``int` `end = nums.length - ``1``;``        ``while` `(start <= end) {``            ``// find the middle element``            ``// int mid = (start + end) / 2;``            ``//  might be possible that (start + end)``            ``//  exceeds the range of int in  java``            ``int` `mid = start + (end - start) / ``2``;` `            ``if` `(target < nums[mid]) {``                ``end = mid - ``1``;``            ``}``            ``else` `if` `(target > nums[mid]) {``                ``start = mid + ``1``;``            ``}``            ``else` `{``                ``// potential ans found``                ``ans = mid;``                ``if` `(findStartIndex) {``                    ``end = mid - ``1``;``                ``}``                ``else` `{``                    ``start = mid + ``1``;``                ``}``            ``}``        ``}` `        ``return` `ans;``    ``}` `    ``// Driver program``    ``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``;``        ``int` `c = count(arr, x);``        ``System.out.println(x + ``" occurs "` `+ c + ``" times"``);``    ``}``}`

## Python3

 `def` `count(nums, target):``    ``# Find the first and last occurrences of the target``    ``first_index ``=` `search(nums, target, ``True``)``    ``last_index ``=` `search(nums, target, ``False``)` `    ``# If both first and last occurrences are found, calculate the count``    ``if` `first_index !``=` `-``1` `and` `last_index !``=` `-``1``:``        ``return` `last_index ``-` `first_index ``+` `1``    ``else``:``        ``return` `0`  `def` `search(nums, target, find_start_index):``    ``# Initialize the answer to -1``    ``ans ``=` `-``1``    ``start ``=` `0``    ``end ``=` `len``(nums) ``-` `1` `    ``# Perform binary search``    ``while` `start <``=` `end:``        ``mid ``=` `start ``+` `(end ``-` `start) ``/``/` `2` `        ``if` `target < nums[mid]:``            ``# If the target is smaller, search in the left half``            ``end ``=` `mid ``-` `1``        ``elif` `target > nums[mid]:``            ``# If the target is larger, search in the right half``            ``start ``=` `mid ``+` `1``        ``else``:``            ``# If the target is found, update the potential answer``            ``ans ``=` `mid``            ``if` `find_start_index:``                ``# Adjust the search range for the first occurrence``                ``end ``=` `mid ``-` `1``            ``else``:``                ``# Adjust the search range for the last occurrence``                ``start ``=` `mid ``+` `1` `    ``return` `ans`  `# Driver program``arr ``=` `[``1``, ``2``, ``2``, ``2``, ``2``, ``3``, ``4``, ``7``, ``8``, ``8``]``n ``=` `len``(arr)``x ``=` `2``c ``=` `count(arr, x)``print``(f``"{x} occurs {c} times"``)`

## C#

 `// C# program for the above approach``using` `System;` `public` `class` `GFG {``    ``/* if x is present in arr[] then returns``    ``the count of occurrences of x,``    ``otherwise returns 0. */``    ``static` `int` `Count(``int``[] arr, ``int` `x)``    ``{``        ``int` `firstIndex = Search(arr, x, ``true``);``        ``int` `lastIndex = Search(arr, x, ``false``);``        ``if` `(firstIndex != -1 && lastIndex != -1)``            ``return` `lastIndex - firstIndex + 1;``        ``else``            ``return` `0;``    ``}` `    ``// if target is present in arr[] then``    ``// returns the index of FIRST``    ``// occurrence and last occurrence of target in``    ``// arr[0..n-1], otherwise returns -1``    ``static` `int` `Search(``int``[] nums, ``int` `target,``                      ``bool` `findStartIndex)``    ``{``        ``int` `ans = -1;``        ``int` `start = 0;``        ``int` `end = nums.Length - 1;``        ``while` `(start <= end) {``            ``// find the middle element``            ``// int mid = (start + end) / 2;``            ``// might be possible that (start + end)``            ``// exceeds the range of int in C#``            ``int` `mid = start + (end - start) / 2;` `            ``if` `(target < nums[mid]) {``                ``end = mid - 1;``            ``}``            ``else` `if` `(target > nums[mid]) {``                ``start = mid + 1;``            ``}``            ``else` `{``                ``// potential ans found``                ``ans = mid;``                ``if` `(findStartIndex) {``                    ``end = mid - 1;``                ``}``                ``else` `{``                    ``start = mid + 1;``                ``}``            ``}``        ``}` `        ``return` `ans;``    ``}` `    ``// Driver program``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };``        ``int` `n = arr.Length;``        ``int` `x = 2;``        ``int` `c = Count(arr, x);``        ``Console.WriteLine(x + ``" occurs "` `+ c + ``" times"``);``    ``}``}` `// This code is contributed by Susobhan Akhuli`

## Javascript

 `// JavaScript program to count occurrences``// of an element` `// Function to count occurrences of x in arr``function` `count(arr, x) {``    ``const firstIndex = search(arr, x, ``true``);``    ``const lastIndex = search(arr, x, ``false``);``    ``if` `(firstIndex !== -1 && lastIndex !== -1)``        ``return` `lastIndex - firstIndex + 1;``    ``else``        ``return` `0;``}` `// Function to search for the index of the target``function` `search(nums, target, findStartIndex) {``    ``let ans = -1;``    ``let start = 0;``    ``let end = nums.length - 1;``    ``while` `(start <= end) {``        ``let mid = start + Math.floor((end - start) / 2);` `        ``if` `(target < nums[mid]) {``            ``end = mid - 1;``        ``}``        ``else` `if` `(target > nums[mid]) {``            ``start = mid + 1;``        ``}``        ``else` `{``            ``ans = mid;``            ``if` `(findStartIndex) {``                ``end = mid - 1;``            ``}``            ``else` `{``                ``start = mid + 1;``            ``}``        ``}``    ``}` `    ``return` `ans;``}` `// Driver program``const arr = [1, 2, 2, 2, 2, 3, 4, 7, 8, 8];``const x = 2;``const c = count(arr, x);``console.log(x + ``" occurs "` `+ c + ``" times"``);` `// This code is contributed by Susobhan Akhuli`

Output
```2 occurs 4 times

```

Time Complexity: O(log n)
Auxiliary Space: O(1)

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

Previous
Next