Javascript Program for Range Queries for Frequencies of array elements

We are given an array that will contain integers and another array will be given that will contain the queries and each query represents the range that we are given by the leftmost and the rightmost index in the array and an element. For that range or the subarray, we have to find the frequency of the given element present in that range.

The frequency of the elements means that we have to tell for each integer present in that range how many times it occurs. For example −

If, the given array is: [5, 2, 5, 3, 1, 5, 2, 2, 5]

The queries array is: [[0, 4, 5], [1, 7, 2]]

• For the first query, the subarray is: 5, 2, 5, 3, and 1, so the frequency of 5 is 2.

• For the second query, the subarray is 2, 5, 3, 1, 5, 2, and 2, so the frequency of 2 is 3.

Approach

To solve this problem, we are going to follow these steps −

• First, we will create a separate function to call for each query and pass the query elements as the parameters.

• Inside the function, we will get the length of the array to traverse over it and will create a variable count to store the frequency of the given element.

• We will use the for loop to traverse in the given range and at each iteration, if the current array element is equal to the given element, then we will increase the count.

• At the end, we will print the current count for the given element.

Example

Let us see the proper code to implement above-given steps for better understanding −

// function to answer their queries 
function findFre(arr, L, R, ele ){
   var n = arr.length 
   var count = 0
   // traversing over the array 
   for(var i = L; i <= R; i++){
      if(arr[i] == ele){
         count++;
      }
   }
   console.log("The frequency of the " + ele + " in the range " + L + " to " + R + " is: " + count);
}
// defining array 
var arr = [5, 2, 5, 3, 1, 5, 2, 2, 5]
console.log("arr =", arr)
var queries = [[0, 4, 5], [1, 7, 2]]
console.log("queries =", queries)
// traversing over the queries array
for(var i = 0; i<queries.length; i++){
   findFre(arr, queries[i][0], queries[i][1], queries[i][2]);
}

Time and Space Complexity

The time complexity of the above code is O(Q*N) where Q is the number of queries and N is the size of the array. Time complexity is the factor of N because we are traversing over the array in the given range, for each query.

The space complexity of the above code is O(1) as we are not using any extra space to store anything.

Special Case

In the above code, we are getting the time complexity of O(Q*N) this can be improved by costing the space complexity if the number of different elements present in the given array is less than for each element a separate array or map can be maintained for prefix sum.

But this method will cost a lot of space which will be O(D*N), where D is the number of the different elements present in the array and N is the length of the array.

By maintaining the prefix sum the answer to any query can be given in the O(1) time and the overall time complexity will be O(Q) where Q is the number of queries.

Example

var store = null;
function lb(a, l, h, k){
   if (l > h){
      return l;
   }
   var m = l + parseInt((h - l) / 2);
   if (k <= a[m]) {
      return lb(a, l, m - 1, k);
   }
   return lb(a, m + 1, h, k);
}
function ub(a, l, h, k){
   if (l > h || l == a.length){
      return l;
   }
   var m = l + parseInt((h - l) / 2);
   if (k >= a[m]){
      return ub(a, m + 1, h, k);
   }
   return ub(a, l, m - 1, k);
}
function findFre(arr, L, R, ele){
   var n = arr.length
   var left_side = lb(store.get(ele), 0, store.get(ele).length, L);
   var right_side = ub(store.get(ele), 0, store.get(ele).length, R);
   var count = right_side - left_side;
   console.log("The frequency of the " + ele + " in the range " + L + " to " + R + " is: " + count);
}
// defining array 
var arr = [5, 2, 5, 3, 1, 5, 2, 2, 5]
console.log("arr =", arr)
// creating a map to store the elements 
store = new Map();
for (var i = 0; i < arr.length; i++){
   if (!store.has(arr[i])){
      store.set(arr[i],new Array());
   }
   store.get(arr[i]).push(i);
}
// creating map for the different elements
// defining queries array 
var queries = [[0, 4, 5], [1, 7, 2]]
console.log("queries =", queries)
// traversing over the queries array
for(var i = 0; i<queries.length; i++){
   findFre(arr, queries[i][0], queries[i][1], queries[i][2]);
}

Conclusion

In this tutorial, we have implemented a JavaScript program to answer the range queries to answer the frequency of the given element in a range provided in each query. We have traversed over the given range in the array and maintained a variable to get the count. The time complexity of the above code is O(Q*N) and the space complexity of the above code is O(1).