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<bits/stdc++.h>
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

<?php
// PHP program to find total count of
// an element in a range

// Returns count of element in
// arr[left-1..right-1]
function findFrequency(&$arr, $n, $left,
                        $right, $element)
{
    $count = 0;
    for ($i = $left - 1; $i <= $right; ++$i)
        if ($arr[$i] == $element)
            ++$count;
    return $count;
}

// Driver Code
$arr = array(2, 8, 6, 9, 8, 6, 8, 2, 11);
$n = sizeof($arr);

// Print frequency of 2 from position 1 to 6
echo "Frequency of 2 from 1 to 6 = ".
      findFrequency($arr, $n, 1, 6, 2) ."\n";

// Print frequency of 8 from position 4 to 9
echo "Frequency of 8 from 4 to 9 = ".
      findFrequency($arr, $n, 4, 9, 8);

// This code is contributed by ita_c
?>

Javascript

<script>

// Javascript Code to find total count of an element
// in a range

    // Returns count of element in arr[left-1..right-1]
    function findFrequency(arr,n,left,right,element)
    {
        let count = 0;
        for (let i = left - 1; i < right; ++i)
            if (arr[i] == element)
                ++count;
        return count;
    }

    /* Driver program to test above function */
    let arr=[2, 8, 6, 9, 8, 6, 8, 2, 11];
    let n = arr.length;

    // Print frequency of 2 from position 1 to 6
    document.write("Frequency of 2 from 1 to 6 = " +
             findFrequency(arr, n, 1, 6, 2)+"<br>");

    // Print frequency of 8 from position 4 to 9
    document.write("Frequency of 8 from 4 to 9 = " +
             findFrequency(arr, n, 4, 9, 8));

    // This code is contributed by rag2127

</script>

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<bits/stdc++.h>
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<n; ++i)
        store[arr[i]].push_back(i+1); //starting index from 1

    // 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 program to find total count of an element
import java.util.*;

public class GFG {

  static HashMap<Integer, ArrayList<Integer> > store;

  static int lower_bound(ArrayList<Integer> 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<Integer> 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.