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++
#include <stdio.h>// 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 codeint 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 elementclass 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 codearr = [1, 2, 2, 2, 2, 3, 4, 7 ,8 ,8]n = len(arr)x = 2print (countOccurrences(arr, n, x)) |
C#
// C# program to count occurrences // of an elementusing 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
<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> |
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?> |
C
#include <stdio.h>int main() { // code return 0;} |
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 <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 -1int 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 codeint 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 elementclass 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 -1def 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 codearr = [ 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 ]n = len(arr)x = 2print(countOccurrences(arr, n, x))# This code is contributed # by ChitraNayal |
C#
// C# program to count // occurrences of an elementusing 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
<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 -1function 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 codevar 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> |
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 -1function 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?> |
C
#include <stdio.h>// A recursive binary search function. It returns// location of x in given array arr[l..r] if present,// otherwise -1int 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 codeint 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;} |
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 <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;} |
Java
// Java program to count occurrences // of an elementclass 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 elementusing 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 codelet 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> |
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;} |
Output:
3 occurs 4 times
Time Complexity: O(Logn)
Auxiliary Space: O(1), as no extra space is used
Programming Paradigm: Divide & Conquer
Method 4 (Using Collections.frequency() method of java)
C++
// C++ program for the above approach#include <bits/stdc++.h>using namespace std;// Function to count occurrencesint 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 Codeint 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 <<x << " occurs " << countOccurrences(arr, x, N) << " times"; return 0;}// This code is contributed by code_hunt. |
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"); }} |
Python3
# Python code to implement the approach# Function to count occurrencesdef countOccurrences(arr, x) : count = 0 n = len(arr) for i in range(n) : if (arr[i] == x): count += 1 return count # Driver Codeif __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 approachusing 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
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-
- First we create an unsorted_map to store elements with their frequency.
- Now we iterate through the array and store its elements inside the map.
- 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 <bits/stdc++.h>using namespace std;// Function to count occurrencesint 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 Codeint 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 approachimport java.util.HashMap;import java.util.Map;public class Main { // Function to count occurrences static int countOccurrences(int[] arr, int x, int N) { Map<Integer, Integer> mp = new HashMap<Integer, Integer>(); 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 occurrencesdef 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 Codearr = [1, 2, 2, 2, 2, 3, 4, 7, 8, 8]x = 2N = len(arr)# displaying the frequency of x in Arrayprint(x, "occurs", countOccurrences(arr, x, N), "times")# This code is contributed by Susobhan Akhuli |
Javascript
// JavaScript program for the above approach// Function to count occurrencesfunction 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 Codelet arr = [1, 2, 2, 2, 2, 3, 4, 7, 8, 8];let x = 2;let N = arr.length;// displaying the frequency of x in Arrayconsole.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 <iostream>#include <vector>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;} |
Java
// Java program to count occurrences// of an elementimport 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"); }} |
C
#include <stdio.h>// 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 codeint 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;} |
Output
2 occurs 4 times
Time Complexity: O(log n)
Auxiliary Space: O(1)
This article is contributed by Aarti_Rathi. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. Please write comments if you find the above codes/algorithms incorrect, or find other ways to solve the same problem.
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
