Question

有人可以解释这个解决方案如何适用于一个练习，让你找到数组中最常见的元素，返回计算它的次数？我是JS的新手，只需要帮助理解逻辑！

   function mostFrequentItemCount(array) {
       var freq = 0;
       var mostFreq = 0;

       for (var i = 0; i <= array.length; i++) {
           for (var j = i; j < array.length; j++) {
               if (array[i] === array[j]) {
                   freq++;
               }
               if (freq >= mostFreq) {
                   mostFreq = freq;
               }
               if (array.length === 0) {
                   return 0;
               }
           }

           freq = 0;
       }

       return mostFreq;
   }

   mostFrequentItemCount([4, 3, 4, 4, 5, 5, 5, 5, 4, 3])

Answer 1

除了注释中提到的错误，它在第一个循环中采用数组的每个元素的逻辑，并将它与之后放置的其他元素（第二个循环从第一个循环当前索引开始）进行比较，并计算出现的次数

IMO必须有一个更优化的方法来做到这一点，因为元素在不相关的情况下被计数多次（当我们遇到第二个时，不再使用省略第一个来计算4）

它也没有处理相同的频率元素。

Answer 2

如果您真的对真正的JS解决方案感兴趣：

    var hashMap = {}; // in js any object can be also used as a map
    var array = [4, 3, 4, 4, 5, 5, 5, 5, 4, 3];
    
    for (var i = 0; i < array.length; i++) // there are better ways of doing this with js es6
    {
        if (!hashMap[array[i]]) hashMap[array[i]] = 0; // if this is the first time of this value in the map - initialize it with zero
    
        hashMap[array[i]]++; // increase the count of each value
    }
    
    for (var value in hashMap)
    {
        console.log(value + ' ' + hashMap[value]); // print each value with the correct amount of instances
    }

Answer 3

应该避免性能方面的嵌套循环，并且我确信有更好的解决方案，但我仍然想让您了解所提供的代码段是如何工作的：

function mostFrequentItemCount(array) {
   // initialize variables
   var freq = 0; // variable that will hold frequency count of the currently checked element
   var mostFreq = 0; // variable that will hold the highest frequency count

   // iterate over all elements of the array
   for (var i = 0; i <= array.length; i++) {
       // from the current index i, iterate over the array again,
       // so all "following" elements will be checked
       for (var j = i; j < array.length; j++) {
           if (array[i] === array[j]) {
               // if one of the following elements equals
               // the current element of the first for loop,
               // increase frequency count
               freq++;
           }
           // if the frequency of this element is higher then the
           // currently highest frequency, set the mostFreq variable
           // to the frequency of the current element
           if (freq >= mostFreq) {
               mostFreq = freq;
           }
           // if the array has no elements, return 0
           if (array.length === 0) {
               return 0;
           }
       }

       // reset freq to 0 so we can start fresh with the next element
       freq = 0;
   }
   // return the most frequent:
   return mostFreq;
}

请注意，这仅适用于仅包含数字的数组（并且将返回频率，而不是最常用的数字，如评论中所述）。当要比较字符串或对象时，必须进行修改以返回实际元素。

Answer 4

另一种解决方案：

function mostFrequentItemCount(array) {
   return array.reduce(function(p,c){
         if(p[c] === undefined)
            p[c] = 0;
         p[c]++;
         if(p.mostFrequent == undefined || p[c]>p[p.mostFrequent])
            p.mostFrequent = c;
         return p;
   },{}).mostFrequent;
}

Answer 5

此函数找不到最频繁的元素，只找到最常见元素出现的次数。

它的工作原理是计算每个元素出现的次数。

外部for循环确保检查数组中的每个元素。内循环计算此元素出现的次数。每当内部循环找到比前一个元素更频繁的元素时，它就会更新mostFreq。

值得注意的是，可以通过使用辅助数组来优化此代码，该数组计算每个元素出现的次数。另外，如注释中所述，循环条件不正确，因为array.length返回数组中的第一个空位。

Javascript的两个循环的说明

5 个答案: