javascript 获取数组中出现次数最多的项

Get the item that appears the most times in an array

提问by p0larBoy

var store = ['1','2','2','3','4'];

I want to find out that 2appear the most in the array. How do I go about doing that?

我想找出2在数组中出现最多的那个。我该怎么做？

回答by codaddict

I would do something like:

我会做这样的事情：

var store = ['1','2','2','3','4'];
var frequency = {};  // array of frequency.
var max = 0;  // holds the max frequency.
var result;   // holds the max frequency element.
for(var v in store) {
        frequency[store[v]]=(frequency[store[v]] || 0)+1; // increment frequency.
        if(frequency[store[v]] > max) { // is this frequency > max so far ?
                max = frequency[store[v]];  // update max.
                result = store[v];          // update result.
        }
}

回答by Nina Scholz

Solution with emphasis to Array.prototype.forEachand the problem of getting more than one key if the max count is shared among more items.

解决方案着重于Array.prototype.forEach，如果最大计数多个项目之间共享获得多于一个关键的问题。

Edit: Proposal with one loop, only.

编辑：只有一个循环的提案。

var store = ['1', '2', '2', '3', '4', '5', '5'],
    distribution = {},
    max = 0,
    result = [];

store.forEach(function (a) {
    distribution[a] = (distribution[a] || 0) + 1;
    if (distribution[a] > max) {
        max = distribution[a];
        result = [a];
        return;
    }
    if (distribution[a] === max) {
        result.push(a);
    }
});
console.log('max: ' + max);
console.log('key/s with max count: ' + JSON.stringify(result));
console.log(distribution);

回答by Ashikodi

arr.sort();
    var max=0,result,freq = 0;
    for(var i=0; i < arr.length; i++){
        if(arr[i]===arr[i+1]){
            freq++;
        }
        else {
            freq=0;
        }
        if(freq>max){
            result = arr[i];
            max = freq;
        }
    }
    return result;

回答by Jamie Wong

Make a histogram, find the key for the maximum number in the histogram.

制作直方图，找到直方图中最大数字的关键。

var hist = [];
for (var i = 0; i < store.length; i++) {
  var n = store[i];
  if (hist[n] === undefined) hist[n] = 0;
  else hist[n]++;
}

var best_count = hist[store[0]];
var best = store[0];
for (var i = 0; i < store.length; i++) {
  if (hist[store[i]] > best_count) {
    best_count = hist[store[i]];
    best = store[i];
  }
}

alert(best + ' occurs the most at ' + best_count + ' occurrences');

This assumes either there are no ties, or you don't care which is selected.

这假设要么没有联系，要么您不在乎选择了哪个。

回答by Cristian Sanchez

If the array is sorted this should work:

如果数组已排序，这应该可以工作：

function popular(array) { 
   if (array.length == 0) return [null, 0];
   var n = max = 1, maxNum = array[0], pv, cv;

   for(var i = 0; i < array.length; i++, pv = array[i-1], cv = array[i]) {
      if (pv == cv) { 
        if (++n >= max) {
           max = n; maxNum = cv;
        }
      } else n = 1;
   }

   return [maxNum, max];
};

popular([1,2,2,3,4,9,9,9,9,1,1])
[9, 4]

popular([1,2,2,3,4,9,9,9,9,1,1,10,10,10,10,10])
[10, 5]

回答by kennebec

This version will quit looking when the count exceeds the number of items not yet counted.

当计数超过尚未计数的项目数时，此版本将停止查找。

It works without sorting the array.

它无需对数组进行排序即可工作。

Array.prototype.most= function(){
    var L= this.length, freq= [], unique= [], 
    tem, max= 1, index, count;
    while(L>= max){
        tem= this[--L];
        if(unique.indexOf(tem)== -1){
            unique.push(tem);
            index= -1, count= 0;
            while((index= this.indexOf(tem, index+1))!= -1){
                ++count;
            }
            if(count> max){
                freq= [tem];
                max= count;
            }
            else if(count== max) freq.push(tem);
        }
    }
    return [freq, max];
}

    //test
    var A= ["apples","oranges","oranges","oranges","bananas",
   "bananas","oranges","bananas"];
    alert(A.most()) // [oranges,4]

    A.push("bananas");
    alert(A.most()) // [bananas,oranges,4]

回答by de Raad

I solved it this way for finding the most common integer

我以这种方式解决了它以找到最常见的整数

function mostCommon(arr) {
    // finds the first most common integer, doesn't account for 2 equally common integers (a tie)

    freq = [];

    // set all frequency counts to 0
    for(i = 0; i < arr[arr.length-1]; i++) {
      freq[i] = 0;
    }

    // use index in freq to represent the number, and the value at the index represent the frequency count 
    for(i = 0; i < arr.length; i++) {
      freq[arr[i]]++; 
    }

    // find biggest number's index, that's the most frequent integer
    mostCommon = freq[0];
    for(i = 0; i < freq.length; i++) {
      if(freq[i] > mostCommon) {
        mostCommon = i;
      }
    }

    return mostCommon;
} 

回答by Reza

This is my solution.

这是我的解决方案。

var max_frequent_elements = function(arr){
var a = [], b = [], prev;
arr.sort();
for ( var i = 0; i < arr.length; i++ ) {
    if ( arr[i] !== prev ) {
        a.push(arr[i]);
        b.push(1);
    } else {
        b[b.length-1]++;
    }
    prev = arr[i];
}


var max = b[0]
for(var p=1;p<b.length;p++){
       if(b[p]>max)max=b[p]
 }

var indices = []
for(var q=0;q<a.length;q++){
   if(b[q]==max){indices.push(a[q])}
}
return indices;

};

};

回答by Augustin Riedinger

All the solutions above are iterative.

以上所有解决方案都是迭代的。

Here's a ES6 functional mutation-less version:

这是一个 ES6 函数式无突变版本：

Array.prototype.mostRepresented = function() {
  const indexedElements = this.reduce((result, element) => {
    return result.map(el => {
      return {
        value: el.value,
        count: el.count + (el.value === element ? 1 : 0),
      };
    }).concat(result.some(el => el.value === element) ? [] : {value: element, count: 1});
  }, []);
  return (indexedElements.slice(1).reduce(
    (result, indexedElement) => (indexedElement.count > result.count ? indexedElement : result),
    indexedElements[0]) || {}).value;
};

It could be optimized in specific situations where performance is the bottleneck, but it has a great advantage of working with anykind of array elements.

它可以在性能成为瓶颈的特定情况下进行优化，但它在处理任何类型的数组元素方面都有很大的优势。

The last line could be replaced with:

最后一行可以替换为：

  return (indexedElements.maxBy(el => el.count) || {}).value;

With:

和：

Array.prototype.maxBy = function(fn) {
  return this.slice(1).reduce((result, element) => (fn(element) > fn(result) ? element : result), this[0]);
};

for clarity

为清楚起见

回答by Collin Rea

This solution returns an array of the most appearing numbers in an array, in case multiple numbers appear at the "max" times.

此解决方案返回数组中出现次数最多的数组，以防多个数字出现在“最大”次数。

    function mode(numbers) {
      var counterObj = {}; 
      var max = 0;
      var result = [];
      for(let num in numbers) {
        counterObj[numbers[num]] = (counterObj[numbers[num]] || 0) + 1; 
        if(counterObj[numbers[num]] >= max) { 
          max = counterObj[numbers[num]];
        }
      }
      for (let num in counterObj) {
        if(counterObj[num] == max) {
          result.push(parseInt(num));
        }
      }
      return result;
    }