Сортируйте массив Javascript по частоте, а затем повторите фильтрацию

Ответ 1

Сначала вычислите частоту каждого элемента.

{
    apples: 1,
    oranges: 4,
    bananas: 2
}

Затем создайте массив из этого частотного объекта, который также удалит дубликаты.

["apples", "oranges", "bananas"]

Теперь отсортируйте этот массив в порядке убывания, используя созданную ранее частотную карту.

function compareFrequency(a, b) {
    return frequency[b] - frequency[a];
}

array.sort(compareFrequency);

Здесь весь источник (с использованием недавно введенных функций массива в ECMA 5) и сочетания шагов генерации дедупликации и частоты,

function sortByFrequency(array) {
    var frequency = {};

    array.forEach(function(value) { frequency[value] = 0; });

    var uniques = array.filter(function(value) {
        return ++frequency[value] == 1;
    });

    return uniques.sort(function(a, b) {
        return frequency[b] - frequency[a];
    });
}

То же, что и выше, используя регулярную итерацию массива.

function sortByFrequencyAndRemoveDuplicates(array) {
    var frequency = {}, value;

    // compute frequencies of each value
    for(var i = 0; i < array.length; i++) {
        value = array[i];
        if(value in frequency) {
            frequency[value]++;
        }
        else {
            frequency[value] = 1;
        }
    }

    // make array from the frequency object to de-duplicate
    var uniques = [];
    for(value in frequency) {
        uniques.push(value);
    }

    // sort the uniques array in descending order by frequency
    function compareFrequency(a, b) {
        return frequency[b] - frequency[a];
    }

    return uniques.sort(compareFrequency);
}

Ответ 2

//возвращает наиболее часто встречающиеся наименее часто используемые

Array.prototype.byCount= function(){
    var itm, a= [], L= this.length, o= {};
    for(var i= 0; i<L; i++){
        itm= this[i];
        if(!itm) continue;
        if(o[itm]== undefined) o[itm]= 1;
        else ++o[itm];
    }
    for(var p in o) a[a.length]= p;
    return a.sort(function(a, b){
        return o[b]-o[a];
    });
}

//тест

var A= ["apples","oranges","oranges","oranges","bananas","bananas","oranges"];
A.byCount()

/* возвращаемое значение: (массив) апельсины, бананы, яблоки */

Ответ 3

Я работал над этим одновременно - решение, которое я придумал, в значительной степени идентично решению Anurag's.

Однако я подумал, что это может стоить обмена, поскольку у меня был несколько другой способ вычисления частоты появления, используя тернарный оператор и проверку, если значение было подсчитано еще несколько иначе.

function sortByFrequencyAndFilter(myArray)
{
    var newArray = [];
    var freq = {};

    //Count Frequency of Occurances
    var i=myArray.length-1;
    for (var i;i>-1;i--)
    {
        var value = myArray[i];
        freq[value]==null?freq[value]=1:freq[value]++;
    }

    //Create Array of Filtered Values
    for (var value in freq)
    {
        newArray.push(value);
    }

    //Define Sort Function and Return Sorted Results
    function compareFreq(a,b)
    {
        return freq[b]-freq[a];
    }

    return newArray.sort(compareFreq);
}

Ответ 4

Основная стратегия:

Создайте объект для использования в качестве хэш-таблицы для отслеживания частоты каждого элемента в массиве, который нужно отсортировать.

Создайте новый массив, содержащий пар элементов, частоты.

Сортировка этого массива по частоте в порядке убывания.

Извлеките элементы из этого массива.

код:

function descendingUniqueSort(toBeSorted) {
    var hash = new Object();
    toBeSorted.forEach(function (element, index, array) { 
                           if (hash[element] == undefined) {
                               hash[element] = 1;
                           }
                           else {
                               hash[element] +=1;
                           }});
    var itemCounts = new Array();
    for (var key in hash) {
       var itemCount = new Object();
       itemCount.key = key;
       itemCount.count = hash[key];
       itemCounts.push(itemCount);
    }
    itemCounts.sort(function(a,b) { if(a.count<b.count) return 1; 
        else if (a.count>b.count) return -1; else return 0;});

    return itemCounts.map(function(itemCount) { return itemCount.key; });
 }

Ответ 5

var arr = ["apples", "oranges", "oranges", "oranges", "bananas", "bananas", "oranges"].sort();
var freq = {};
for (var s in arr) freq[s] = freq[s] ? freq[s] + 1 : 0;
arr.sort(function(a, b) { return freq[a] > freq[b] ? -1 : 1; });
for (var i = arr.length - 1; i > 0; i--) if (arr[i] == arr[i - 1]) arr.splice(i,1);
alert(arr.join(","));

Ответ 6

для первого шага вычисления

{
    oranges: 4,
    bananas: 2,
    apples: 1
}

вы можете использовать функцию countBy для underscroe.js

var all=["apples", "oranges", "oranges", "oranges", "bananas", "bananas", "oranges"];
var frequency=_.countBy(all,function(each){return each});

поэтому объект frequency будет содержать частоту всех уникальных значений, и вы можете получить уникальный список, просто позвонив _.uniq(all) и отсортировать этот уникальный список с помощью метода _.sortBy подчёркивания и используя frequency объект, который вы можете использовать

_.sortBy(_.uniq(all),function(frequencyKey){return -frequency[frequencyKey]});

-ve используется здесь для сортировки списка в порядке убывания с помощью значения частоты согласно вашему требованию.

Вы можете проверить документацию http://underscorejs.org/ для дальнейшей оптимизации по своему трюку:)

Ответ 7

Для ES6 просто коды с .filter и .sort, как показано ниже

> var arr = ["apples", "oranges", "oranges", "oranges", "bananas", "bananas", "oranges"];
> arr.filter((key, idx) => arr.lastIndexOf(key) === idx).sort((a, b) => a < b ? -1 : 1);
  ["apples", "bananas", "oranges"]

Ответ 8

Позвольте мне добавить минимальный код для получения уникальных значений (и с частотами) в ES6.

var arr = ["apples", "oranges", "oranges", "oranges", "bananas", "bananas", "oranges"];
console.log([...new Set(arr)])