JavaScript program to calculate frequency of array elements

Calculating frequency means we have to count the number of times an element in an array appears in a given array. We can use some built-in data structure like map to get the frequencies or we can sort the array to get the frequencies of the array elements. We will discuss both methods, let’s look at them one by one -

Sort the array

In this method we will sort the array and check if the current element is the same as the previous element, if the current array is not the same then this is the new element and the frequency of the previous element till the count is a variable , which we will use to increment the count of elements.

method

• First, we will sort the array using the built-in sorting method.

• We will create an array that will store the elements in the given array and their respective frequencies.

• We will create a variable "count" to store the number of occurrences of the current element.

• We will iterate over the array and on each iteration check if the current element is equal to the previous element.

• If the current element is equal to the previous element, then we will increase the count value.

• If the current element is not equal to the previous element, then we store the count of the previous element as a key pair in the array indicating the frequency of the current element.

  李>

• Also, we will update the count value to 1.

• After iterating the array we will store the frequency of the last element of the sorted array as it will not be stored and the loop ends.

Example

Let us see the code that implements the above method and add and understand it in a better way.

// given array 
var arr = [ 1, 4, 5, 6, 2, 2, 2, 4, 5, 5, 4, 6, 9, 1, 2, 2, 3]

// sorting the array 
arr.sort()

var count = 1 

for(var i = 1;i<arr.length; i++){
   if(arr[i] == arr[i-1]) {
      count++;
   }
   else {
      console.log("The frequency of "+ arr[i-1] + " is: " + count);
      count = 1;
   }
}

console.log("The frequency of "+ arr[arr.length-1] + " is: " + count);

Time and space complexity

The time complexity of the above code is O(N*log(N)), because we have sorted the array, and the time required is N*log(N), and we have traversed the array once, need O(N ) time, where N is the number of elements present in the given array.

The space complexity of the above code is O(1) because we are not using any extra space, but if we want to store the frequency, then there will be some extra space and that is O(N).

How often all elements of the map are used

A map is a data structure that stores values ​​in the form of key pairs, and the data can be updated later. Adding or updating data in the map takes logarithmic time, but does not require sorting the array, which means we do not have to change the array like we did in the previous program. Let's look at the methods first and then we'll get into the encoding part -

method

• First, we will create the map using the new keyword.

• We will iterate over the array and check each element.

• If the current element exists in the map, then we will increment the value stored for the current element, which is the frequency.

• If the element is not stored, then we add it as a key to the map and give it the value 1.

• After iterating the array, we can print the values ​​stored in the map as key-value pairs.

Example

We have seen how the code is implemented, now let’s move into the implementation part to understand the code better -

// given array 
var arr = [ 1, 4, 5, 6, 2, 2, 2, 4, 5, 5, 4, 6, 9, 1, 2, 2, 3]
var map = new Map()
for(var i = 0;i<arr.length; i++){
   if(map.has(arr[i])){
      var k = map.get(arr[i]);
      map.delete(arr[i]);
      map.set(arr[i],k+1)
   }
   else{
      map.set(arr[i],1);
   }
}
console.log(map)

Time and space complexity

The time complexity of the above code is O(N*log(N)), where N is the size of the array, factor or log depending on how the mapping works. The above code has a space complexity of O(N) and requires storing elements in the map.

Using a map to find frequencies is good because we don't have to change the given array.

in conclusion

In this tutorial, we will introduce a JavaScript program for calculating the frequency of array elements. Calculating frequency means we have to count the number of times an element in an array appears in a given array. We have seen two ways to solve the given problem, one is to sort the elements using the built-in sorting function and the other is to do it using the built-in map data structure.

The above is the detailed content of JavaScript program to calculate frequency of array elements. For more information, please follow other related articles on the PHP Chinese website!