# Range Queries for Frequencies of array elements

Last Updated : 12 Sep, 2023

Given an array of n non-negative integers. The task is to find frequency of a particular element in the arbitrary range of array[]. The range is given as positions (not 0 based indexes) in array. There can be multiple queries of given type.

Examples:

```Input  : arr[] = {2, 8, 6, 9, 8, 6, 8, 2, 11};
left = 2, right = 8, element = 8
left = 2, right = 5, element = 6
Output : 3
1
The element 8 appears 3 times in arr[left-1..right-1]
The element 6 appears 1 time in arr[left-1..right-1]```

Naive approach: is to traverse from left to right and update count variable whenever we find the element.

Below is the code of Naive approach:-

## C++

 `// C++ program to find total count of an element ` `// in a range ` `#include ` `using` `namespace` `std; ` ` `  `// Returns count of element in arr[left-1..right-1] ` `int` `findFrequency(``int` `arr[], ``int` `n, ``int` `left, ` `                         ``int` `right, ``int` `element) ` `{ ` `    ``int` `count = 0; ` `    ``for` `(``int` `i=left-1; i<=right; ++i) ` `        ``if` `(arr[i] == element) ` `            ``++count; ` `    ``return` `count; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `arr[] = {2, 8, 6, 9, 8, 6, 8, 2, 11}; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ` ` `  `    ``// Print frequency of 2 from position 1 to 6 ` `    ``cout << ``"Frequency of 2 from 1 to 6 = "` `         ``<< findFrequency(arr, n, 1, 6, 2) << endl; ` ` `  `    ``// Print frequency of 8 from position 4 to 9 ` `    ``cout << ``"Frequency of 8 from 4 to 9 = "` `         ``<< findFrequency(arr, n, 4, 9, 8); ` ` `  `    ``return` `0; ` `} `

## Java

 `// JAVA Code to find total count of an element ` `// in a range ` ` `  `class` `GFG { ` `     `  `    ``// Returns count of element in arr[left-1..right-1] ` `    ``public` `static` `int` `findFrequency(``int` `arr[], ``int` `n,  ` `                                ``int` `left, ``int` `right, ` `                                      ``int` `element) ` `    ``{ ` `        ``int` `count = ``0``; ` `        ``for` `(``int` `i = left - ``1``; i < right; ++i) ` `            ``if` `(arr[i] == element) ` `                ``++count; ` `        ``return` `count; ` `    ``} ` `     `  `    ``/* Driver program to test above function */` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``int` `arr[] = {``2``, ``8``, ``6``, ``9``, ``8``, ``6``, ``8``, ``2``, ``11``}; ` `        ``int` `n = arr.length; ` `      `  `        ``// Print frequency of 2 from position 1 to 6 ` `        ``System.out.println(``"Frequency of 2 from 1 to 6 = "` `+ ` `             ``findFrequency(arr, n, ``1``, ``6``, ``2``)); ` `      `  `        ``// Print frequency of 8 from position 4 to 9 ` `        ``System.out.println(``"Frequency of 8 from 4 to 9 = "` `+ ` `             ``findFrequency(arr, n, ``4``, ``9``, ``8``)); ` `         `  `    ``} ` `  ``}  ` `// This code is contributed by Arnav Kr. Mandal. `

## Python3

 `# Python program to find total   ` `# count of an element in a range ` ` `  `# Returns count of element ` `# in arr[left-1..right-1] ` `def` `findFrequency(arr, n, left, right, element): ` ` `  `    ``count ``=` `0` `    ``for` `i ``in` `range``(left ``-` `1``, right): ` `        ``if` `(arr[i] ``=``=` `element): ` `            ``count ``+``=` `1` `    ``return` `count ` ` `  ` `  `# Driver Code ` `arr ``=` `[``2``, ``8``, ``6``, ``9``, ``8``, ``6``, ``8``, ``2``, ``11``] ` `n ``=` `len``(arr) ` ` `  `# Print frequency of 2 from position 1 to 6 ` `print``(``"Frequency of 2 from 1 to 6 = "``, ` `        ``findFrequency(arr, n, ``1``, ``6``, ``2``)) ` ` `  `# Print frequency of 8 from position 4 to 9 ` `print``(``"Frequency of 8 from 4 to 9 = "``, ` `        ``findFrequency(arr, n, ``4``, ``9``, ``8``)) ` `         `  `     `  `# This code is contributed by Anant Agarwal. `

## C#

 `// C# Code to find total count  ` `// of an element in a range ` `using` `System; ` ` `  `class` `GFG { ` `     `  `    ``// Returns count of element  ` `    ``// in arr[left-1..right-1] ` `    ``public` `static` `int` `findFrequency(``int` `[]arr, ``int` `n,  ` `                                    ``int` `left, ``int` `right, ` `                                    ``int` `element) ` `    ``{ ` `        ``int` `count = 0; ` `        ``for` `(``int` `i = left - 1; i < right; ++i) ` `            ``if` `(arr[i] == element) ` `                ``++count; ` `        ``return` `count; ` `    ``} ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `Main()  ` `    ``{ ` `        ``int` `[]arr = {2, 8, 6, 9, 8, 6, 8, 2, 11}; ` `        ``int` `n = arr.Length; ` `     `  `        ``// Print frequency of 2  ` `        ``// from position 1 to 6 ` `        ``Console.WriteLine(``"Frequency of 2 from 1 to 6 = "` `+ ` `                            ``findFrequency(arr, n, 1, 6, 2)); ` `     `  `        ``// Print frequency of 8  ` `        ``// from position 4 to 9 ` `        ``Console.Write(``"Frequency of 8 from 4 to 9 = "` `+ ` `                       ``findFrequency(arr, n, 4, 9, 8)); ` `         `  `    ``} ` `}  ` ` `  `// This code is contributed by Nitin Mittal. `

## PHP

 ` `

## Javascript

 ``

Output

```Frequency of 2 from 1 to 6 = 1
Frequency of 8 from 4 to 9 = 2```

Time complexity of this approach is O(right – left + 1) or O(n)
Auxiliary space: O(1)

An Efficient approach is to use hashing. In C++, we can use unordered_map

• At first, we will store the position in map[] of every distinct element as a vector like that
```  int arr[] = {2, 8, 6, 9, 8, 6, 8, 2, 11};
map[2] = {1, 8}
map[8] = {2, 5, 7}
map[6] = {3, 6}
ans so on...```
• As we can see that elements in map[] are already in sorted order (Because we inserted elements from left to right), the answer boils down to find the total count in that hash map[] using binary search like method.

• In C++ we can use lower_bound which will returns an iterator pointing to the first element in the range [first, last] which has a value not less than ‘left’. and upper_bound returns an iterator pointing to the first element in the range [first,last) which has a value greater than ‘right’.

• After that we just need to subtract the upper_bound() and lower_bound() result to get the final answer. For example, suppose if we want to find the total count of 8 in the range from [1 to 6], then the map[8] of lower_bound() function will return the result 0 (pointing to 2) and upper_bound() will return 2 (pointing to 7), so we need to subtract the both the result like 2 – 0 = 2 .

Below is the code of above approach

## C++

 `// C++ program to find total count of an element ` `#include ` `using` `namespace` `std; ` ` `  `unordered_map< ``int``, vector<``int``> > store; ` ` `  `// Returns frequency of element in arr[left-1..right-1] ` `int` `findFrequency(``int` `arr[], ``int` `n, ``int` `left, ` `                      ``int` `right, ``int` `element) ` `{ ` `    ``// Find the position of first occurrence of element ` `    ``int` `a = lower_bound(store[element].begin(), ` `                        ``store[element].end(), ` `                        ``left) ` `            ``- store[element].begin(); ` ` `  `    ``// Find the position of last occurrence of element ` `    ``int` `b = upper_bound(store[element].begin(), ` `                        ``store[element].end(), ` `                        ``right) ` `            ``- store[element].begin(); ` ` `  `    ``return` `b-a; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = {2, 8, 6, 9, 8, 6, 8, 2, 11}; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ` ` `  `    ``// Storing the indexes of an element in the map ` `    ``for` `(``int` `i=0; i

## Java

 `// Java program to find total count of an element ` `import` `java.util.*; ` ` `  `public` `class` `GFG { ` ` `  `  ``static` `HashMap > store; ` ` `  `  ``static` `int` `lower_bound(ArrayList a, ``int` `low, ` `                         ``int` `high, ``int` `key) ` `  ``{ ` `    ``if` `(low > high) { ` `      ``return` `low; ` `    ``} ` `    ``int` `mid = low + (high - low) / ``2``; ` `    ``if` `(key <= a.get(mid)) { ` ` `  `      ``return` `lower_bound(a, low, mid - ``1``, key); ` `    ``} ` `    ``return` `lower_bound(a, mid + ``1``, high, key); ` `  ``} ` ` `  `  ``static` `int` `upper_bound(ArrayList a, ``int` `low, ` `                         ``int` `high, ``int` `key) ` `  ``{ ` `    ``if` `(low > high || low == a.size()) ` `      ``return` `low; ` `    ``int` `mid = low + (high - low) / ``2``; ` `    ``if` `(key >= a.get(mid)) { ` `      ``return` `upper_bound(a, mid + ``1``, high, key); ` `    ``} ` `    ``return` `upper_bound(a, low, mid - ``1``, key); ` `  ``} ` ` `  `  ``// Returns frequency of element in arr[left-1..right-1] ` `  ``static` `int` `findFrequency(``int` `arr[], ``int` `n, ``int` `left, ` `                           ``int` `right, ``int` `element) ` `  ``{ ` `    ``// Find the position of first occurrence of element ` `    ``int` `a ` `      ``= lower_bound(store.get(element), ``0``, ` `                    ``store.get(element).size(), left); ` ` `  `    ``// Find the position of last occurrence of element ` `    ``int` `b ` `      ``= upper_bound(store.get(element), ``0``, ` `                    ``store.get(element).size(), right); ` ` `  `    ``return` `b - a; ` `  ``} ` ` `  `  ``// Driver code ` `  ``public` `static` `void` `main(String[] args) ` `  ``{ ` `    ``int` `arr[] = { ``2``, ``8``, ``6``, ``9``, ``8``, ``6``, ``8``, ``2``, ``11` `}; ` `    ``int` `n = arr.length; ` ` `  `    ``// Storing the indexes of an element in the map ` `    ``store = ``new` `HashMap<>(); ` `    ``for` `(``int` `i = ``0``; i < n; ++i) { ` `      ``if` `(!store.containsKey(arr[i])) ` `        ``store.put(arr[i], ``new` `ArrayList<>()); ` `      ``store.get(arr[i]).add( ` `        ``i + ``1``); ``// starting index from 1 ` `    ``} ` ` `  `    ``// Print frequency of 2 from position 1 to 6 ` `    ``System.out.println( ` `      ``"Frequency of 2 from 1 to 6 = "` `      ``+ findFrequency(arr, n, ``1``, ``6``, ``2``)); ` ` `  `    ``// Print frequency of 8 from position 4 to 9 ` `    ``System.out.println( ` `      ``"Frequency of 8 from 4 to 9 = "` `      ``+ findFrequency(arr, n, ``4``, ``9``, ``8``)); ` `  ``} ` `} ` ` `  `// This code is contributed by Karandeep1234`

## Python3

 `# Python3 program to find total count of an element ` `from` `collections ``import` `defaultdict as ``dict` `from` `bisect ``import` `bisect_left as lower_bound ` `from` `bisect ``import` `bisect_right as upper_bound ` ` `  `store ``=` `dict``(``list``) ` ` `  `# Returns frequency of element  ` `# in arr[left-1..right-1] ` `def` `findFrequency(arr, n, left, right, element): ` `     `  `    ``# Find the position of  ` `    ``# first occurrence of element ` `    ``a ``=` `lower_bound(store[element], left) ` ` `  `    ``# Find the position of ` `    ``# last occurrence of element ` `    ``b ``=` `upper_bound(store[element], right) ` ` `  `    ``return` `b ``-` `a ` ` `  `# Driver code ` `arr ``=` `[``2``, ``8``, ``6``, ``9``, ``8``, ``6``, ``8``, ``2``, ``11``] ` `n ``=` `len``(arr) ` ` `  `# Storing the indexes of ` `# an element in the map ` `for` `i ``in` `range``(n): ` `    ``store[arr[i]].append(i ``+` `1``) ` ` `  `# Print frequency of 2 from position 1 to 6 ` `print``(``"Frequency of 2 from 1 to 6 = "``,  ` `       ``findFrequency(arr, n, ``1``, ``6``, ``2``)) ` ` `  `# Print frequency of 8 from position 4 to 9 ` `print``(``"Frequency of 8 from 4 to 9 = "``, ` `       ``findFrequency(arr, n, ``4``, ``9``, ``8``)) ` ` `  `# This code is contributed by Mohit Kumar `

## C#

 `// C# program to find total count of an element ` ` `  `using` `System; ` `using` `System.Collections; ` `using` `System.Collections.Generic; ` ` `  `public` `class` `GFG { ` ` `  `    ``static` `Dictionary<``int``, List<``int``> > store; ` ` `  `    ``static` `int` `lower_bound(List<``int``> a, ``int` `low, ``int` `high, ` `                           ``int` `key) ` `    ``{ ` `        ``if` `(low > high) { ` `            ``return` `low; ` `        ``} ` `        ``int` `mid = low + (high - low) / 2; ` `        ``if` `(key <= a[mid]) { ` ` `  `            ``return` `lower_bound(a, low, mid - 1, key); ` `        ``} ` `        ``return` `lower_bound(a, mid + 1, high, key); ` `    ``} ` ` `  `    ``static` `int` `upper_bound(List<``int``> a, ``int` `low, ``int` `high, ` `                           ``int` `key) ` `    ``{ ` `        ``if` `(low > high || low == a.Count) ` `            ``return` `low; ` `        ``int` `mid = low + (high - low) / 2; ` `        ``if` `(key >= a[mid]) { ` `            ``return` `upper_bound(a, mid + 1, high, key); ` `        ``} ` `        ``return` `upper_bound(a, low, mid - 1, key); ` `    ``} ` ` `  `    ``// Returns frequency of element in arr[left-1..right-1] ` `    ``static` `int` `findFrequency(``int``[] arr, ``int` `n, ``int` `left, ` `                             ``int` `right, ``int` `element) ` `    ``{ ` `        ``// Find the position of first occurrence of element ` `        ``int` `a = lower_bound(store[element], 0, ` `                            ``store[element].Count, left); ` ` `  `        ``// Find the position of last occurrence of element ` `        ``int` `b = upper_bound(store[element], 0, ` `                            ``store[element].Count, right); ` ` `  `        ``return` `b - a; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(``string``[] args) ` `    ``{ ` `        ``int``[] arr = { 2, 8, 6, 9, 8, 6, 8, 2, 11 }; ` `        ``int` `n = arr.Length; ` ` `  `        ``// Storing the indexes of an element in the map ` `        ``store = ``new` `Dictionary<``int``, List<``int``> >(); ` `        ``for` `(``int` `i = 0; i < n; ++i) { ` `            ``if` `(!store.ContainsKey(arr[i])) ` `                ``store.Add(arr[i], ``new` `List<``int``>()); ` `            ``store[arr[i]].Add(i ` `                              ``+ 1); ``// starting index from 1 ` `        ``} ` ` `  `        ``// Print frequency of 2 from position 1 to 6 ` `        ``Console.WriteLine(``"Frequency of 2 from 1 to 6 = "` `                          ``+ findFrequency(arr, n, 1, 6, 2)); ` ` `  `        ``// Print frequency of 8 from position 4 to 9 ` `        ``Console.WriteLine(``"Frequency of 8 from 4 to 9 = "` `                          ``+ findFrequency(arr, n, 4, 9, 8)); ` `    ``} ` `} ` ` `  `// This code is contributed by Karandeep1234`

## Javascript

 `   ``var` `store = ``null``; ` `  ``function` `lower_bound(a, low, high, key) ` `  ``{ ` `      ``if` `(low > high) ` `      ``{ ` `          ``return` `low; ` `      ``} ` `      ``var` `mid = low + parseInt((high - low) / 2); ` `      ``if` `(key <= a[mid]) ` `      ``{ ` `          ``return` `lower_bound(a, low, mid - 1, key); ` `      ``} ` `      ``return` `lower_bound(a, mid + 1, high, key); ` `  ``} ` `  ``function` `upper_bound(a, low, high, key) ` `  ``{ ` `      ``if` `(low > high || low == a.length) ` `      ``{ ` `          ``return` `low; ` `      ``} ` `      ``var` `mid = low + parseInt((high - low) / 2); ` `      ``if` `(key >= a[mid]) ` `      ``{ ` `          ``return` `upper_bound(a, mid + 1, high, key); ` `      ``} ` `      ``return` `upper_bound(a, low, mid - 1, key); ` `  ``} ` `   `  `  ``// Returns frequency of element in arr[left-1..right-1] ` `  ``function` `findFrequency(arr, n, left, right, element) ` `  ``{ ` `   `  `      ``// Find the position of first occurrence of element ` `      ``var` `a = lower_bound(store.get(element), 0, store.get(element).length, left); ` `       `  `      ``// Find the position of last occurrence of element ` `      ``var` `b = upper_bound(store.get(element), 0, store.get(element).length, right); ` `      ``return` `b - a; ` `  ``} ` `  ``// Driver code ` `   `  `      ``var` `arr = [2, 8, 6, 9, 8, 6, 8, 2, 11]; ` `      ``var` `n = arr.length; ` `       `  `      ``// Storing the indexes of an element in the map ` `      ``store = ``new` `Map(); ` `      ``var` `i=0; ` `      ``for` `(i; i < n; ++i) ` `      ``{ ` `          ``if` `(!store.has(arr[i])) ` `          ``{ ` `              ``store.set(arr[i],``new` `Array()); ` `          ``} ` `          ``(store.get(arr[i]).push(i + 1) > 0); ` `      ``} ` `       `  `      ``// Print frequency of 2 from position 1 to 6 ` `      ``console.log(``"Frequency of 2 from 1 to 6 = "` `+ findFrequency(arr, n, 1, 6, 2)); ` `       `  `      ``// Print frequency of 8 from position 4 to 9 ` `      ``console.log(``"Frequency of 8 from 4 to 9 = "` `+ findFrequency(arr, n, 4, 9, 8)); ` ` `  `// This code is contributed by sourabhdalal0001.`

Output

```Frequency of 2 from 1 to 6 = 1
Frequency of 8 from 4 to 9 = 2```

This approach will be beneficial if we have a large number of queries of an arbitrary range asking the total frequency of particular element.
Time complexity: O(log N) for single query.
Auxiliary Space: O(N)

Previous
Next