logo标签列表

在一个数组中获取出现次数最高的元素

javascriptmode
123

我正在寻找一种优雅的方法来确定JavaScript数组中出现率最高的元素（mode）。

例如，在以下数组中：

['pear', 'apple', 'orange', 'apple']

'apple'元素是最常见的一个。

你可以从这个Stackoverflow问题中借鉴一些想法。https://dev59.com/eXRA5IYBdhLWcg3wvgsb - Nosredna
我没有仔细阅读解决方案，但它们中是否有任何一种考虑了以下细微差别（优化？），基于仅需确定哪个元素具有最多出现次数的要求，而不是最多出现次数是多少...当循环数组时，如果计数可以停止，则差异在最高和次高出现次数之间小于剩余要循环的元素数量，循环可以停止，当前最高值将是最高值。 - Dexygen
这是一个与编程语言无关的问题，位于算法-在大型单词序列中查找前K个频繁单词的最有效方法-堆栈溢出。 - user202729
44个回答
0
var cats = ['Tom','Fluffy','Tom','Bella','Chloe','Tom','Chloe'];
var counts = {};
var compare = 0;
var mostFrequent;
(function(array){
   for(var i = 0, len = array.length; i < len; i++){
       var word = array[i];

       if(counts[word] === undefined){
           counts[word] = 1;
       }else{
           counts[word] = counts[word] + 1;
       }
       if(counts[word] > compare){
             compare = counts[word];
             mostFrequent = cats[i];
       }
    }
  return mostFrequent;
})(cats);
0

可以尝试：

var arr = [10,3,4,5,3,4,3,8,3,6,3,5,1];
var temp = {};

for(let i=0;i<arr.length;i++){
    if(temp[arr[i]]==undefined){
       temp[arr[i]]=1;
    }else{
        temp[arr[i]]+=1;
    }
}

var max=0, maxEle;

for(const i in temp){
    if(temp[i]>max){
        max = temp[i];
        maxEle=i;
    }
}

console.log(`most occurred element is ${maxEle} and number of times is ${max}`);`
1
如果数组中有两个数字具有相同的频率，则条件将失败。示例 var arr = [1,2,2,3,1]; - Inamur Rahman
同意，这将返回第一个出现的元素。 - jaibalaji
0
function mode(){
  var input = $("input").val().split(",");
  var mode = [];
  var m = [];
  var p = [];
    for(var x = 0;x< input.length;x++){
      if(m.indexOf(input[x])==-1){
        m[m.length]=input[x];
    }}
  for(var x = 0; x< m.length;x++){
    p[x]=0;
    for(var y = 0; y<input.length;y++){
      if(input[y]==m[x]){
      p[x]++; 
 }}}
 for(var x = 0;x< p.length;x++){
   if(p[x] ==(Math.max.apply(null, p))){
     mode.push(m[x]);
 }} 
$("#output").text(mode);}
0

我看到很多答案都通过数组进行了很多递归，而我想避免这种情况。除此之外，我希望使用Typescript检查结果并推断正确的类型。

所以这是我的版本：

function findhighestOccurence<Type extends string | number>(myArray: Type[]) {
    const countOccorrencies = myArray.reduce<{ [key in Type]: number }>(
        (acc, curr) => ({ ...acc, [curr]: acc[curr] ? acc[curr] + 1 : 1 }),
        {} as { [K in Type]: number }
    )

    return (Object.entries(countOccorrencies) as [Type, number][]).reduce<{
        values: Type[] // there might be multiple "highest occurences" values
        occurrences: number // how many times it has/they have occurred
    }>(
        (acc, [value, occurrences]) => {
            // new highest occurrence
            if (occurrences > acc.occurrences)
                return {
                    ...acc,
                    occurrences: occurrences,
                    values: [value],
                }
            // new value with same highest amount of occurrences
            else if (occurrences === acc.occurrences)
                return { ...acc, values: [...acc.values, value] }
            return acc
        },
        { values: [], occurrences: 0 }
    )
}

简明版：

function findhighestOccurenceShort<T extends string | number>(myArray: T[]) {
    return (
        Object.entries(
            myArray.reduce<{ [key in T]: number }>(
                (acc, cur) => ({ ...acc, [cur]: acc[cur] ? acc[cur] + 1 : 1 }),
                {} as { [K in T]: number }
            )
        ) as [T, number][]
    ).reduce<{ val: T[]; occ: number }>(
        (acc, [val, occ]) =>
            occ > acc.occ
                ? { occ, val: [val] }
                : occ === acc.occ
                ? { occ, val: [...acc.val, val] }
                : acc,
        { val: [], occ: 0 }
    )
}
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接