获取数组中出现次数最多的元素

Question

我正在寻找一种优雅的方法来确定 JavaScript 数组中哪个元素出现次数最多 (mode)。

例如，在

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

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

Answer 1

可以试试：

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}`);`

Answer 2

已经有很多答案了，但只是想与您分享我的想法:) 不能说这个解决方案依赖于任何边缘情况，但无论如何）

const getMostFrequentElement = ( arr ) => {
  const counterSymbolKey = 'counter'
  const mostFrequentSymbolKey = 'mostFrequentKey'

  const result = arr.reduce( ( acc, cur ) => {
    acc[ cur ] = acc[ cur ] ? acc[ cur ] + 1 : 1

    if ( acc[ cur ] > acc[ Symbol.for( counterSymbolKey ) ] ) {
      acc[ Symbol.for( mostFrequentSymbolKey ) ] = cur
      acc[ Symbol.for( counterSymbolKey ) ] = acc[ cur ]
    }

    return acc
  }, {
    [ Symbol.for( mostFrequentSymbolKey ) ]: null,
    [ Symbol.for( counterSymbolKey ) ]: 0
  } )

  return result[ Symbol.for( mostFrequentSymbolKey ) ]
}

希望对某人有所帮助）

Answer 3

我想出了一个更短的解决方案，但它使用的是 lodash。适用于任何数据，而不仅仅是字符串。对于可以使用的对象：

const mostFrequent = _.maxBy(Object.values(_.groupBy(inputArr, el => el.someUniqueProp)), arr => arr.length)[0];

这是用于字符串的：

const mostFrequent = _.maxBy(Object.values(_.groupBy(inputArr, el => el)), arr => arr.length)[0];

只是按照一定的标准对数据进行分组，然后找到最大的组。

Answer 4

这是我的方法，只需使用.filter。

var arr = ['pear', 'apple', 'orange', 'apple'];

function dup(arrr) {
    let max = { item: 0, count: 0 };
    for (let i = 0; i < arrr.length; i++) {
        let arrOccurences = arrr.filter(item => { return item === arrr[i] }).length;
        if (arrOccurences > max.count) {
            max = { item: arrr[i], count: arrr.filter(item => { return item === arrr[i] }).length };
        }
    }
    return max.item;
}
console.log(dup(arr));

Answer 5

这个解决方案的复杂度为 O(n)

function findhighestOccurenceAndNum(a){
    let obj={};
    let maxNum;
    let maxVal;
    for(let v of a){
        obj[v]= ++obj[v] ||1;
        if(maxVal === undefined || obj[v]> maxVal){
            maxNum= v;
            maxVal=obj[v];
        }
    }
    console.log(maxNum + 'has max value = ', maxVal);
}

Answer 6

简单的解决方案！

function mostFrequentElement(arr) {
    let res = [];
    for (let x of arr) {
        let count = 0;
        for (let i of arr) {
            if (i == x) {
                count++;
            }
        }
        res.push(count);
    }
    return arr[res.indexOf(Math.max(...res))];
}
array = [13 , 2 , 1 , 2 , 10 , 2 , 1 , 1 , 2 , 2];
let frequentElement = mostFrequentElement(array);
console.log(`The frequent element in ${array} is ${frequentElement}`);

循环所有元素并收集数组中每个元素的计数，这是解决方案的想法

Answer 7

//const arr = [1, 2, 4, 3, 5, 1, 2, 3, 3];
const arr = ['pear', 'apple', 'orange', 'apple'];

// init max occurance element
let maxOcc = {'element': null, occured: 0};

// to find occurances
const res = arr.reduce((acc, el) => {
    acc[el] = acc[el] ? acc[el]+1 : 1;
    if(acc[el]> maxOcc.occured){
        maxOcc = { 'element': el, occured: acc[el] };
    }
    return acc;
}, {});

console.log(maxOcc);

Answer 8

这是我的解决方案：-

 const arr = [
2, 1, 10, 7, 10, 3, 10, 8, 7, 3, 10, 5, 4, 6, 7, 9, 2, 2, 2, 6, 3, 7, 6, 9, 8,
9, 10, 8, 8, 8, 4, 1, 9, 3, 4, 5, 8, 1, 9, 3, 2, 8, 1, 9, 6, 3, 9, 2, 3, 5, 3,
2, 7, 2, 5, 4, 5, 5, 8, 4, 6, 3, 9, 2, 3, 3, 10, 3, 3, 1, 4, 5, 4, 1, 5, 9, 6,
2, 3, 10, 9, 4, 3, 4, 5, 7, 2, 7, 2, 9, 8, 1, 8, 3, 3, 3, 3, 1, 1, 3,
];

function max(arr) {
let newObj = {};

arr.forEach((d, i) => {
    if (newObj[d] != undefined) {
        ++newObj[d];
    } else {
        newObj[d] = 0;
    }
});
let nwres = {};
for (let maxItem in newObj) {
    if (newObj[maxItem] == Math.max(...Object.values(newObj))) {
        nwres[maxItem] = newObj[maxItem];
    }
}
return nwres;
}


console.log(max(arr));