 GeeksforGeeks App
Open App Browser
Continue

# Range Queries for Frequencies of array elements

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);` `    ``// 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 = {1, 8}
map = {2, 5, 7}
map = {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 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);` `    ``// 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)

This article is contributed by Shubham Bansal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up