从数组返回排序的唯一值，但如果计数相等，则按顺序返回值

Question

我正在创建一个函数，该函数接收未排序的整数数组并返回按频率排序的唯一整数数组。但是，如果整数具有相同的频率，则它们将按输入数组的原始顺序返回。这是我目前的函数：

function uniqueUnionSorted(arr) {
counter = {};
for(var i=0; i<arr.length; i++) {
if (arr[i] in counter) {
counter[arr[i]] ++;
} else {
counter[arr[i]] = 1;
}
}
sortedStrings = Object.keys(counter).sort(function(a,b) {
return counter[b] - counter[a]
});
var sortedNumbers = sortedStrings.map(Number);
return sortedNumbers;
}

所以对于这样的数组：

arr = [1, 3, 2, 1, 5, 2, 1, 4]

该函数应返回：

[1,2,3,5,4]

但是，我的函数正在对 5 和 4 进行排序并返回：

[1,2,3,4,5]

请帮忙！

Answer 1

这种重新排序的原因是，当使用Object.keys()时，数字对象属性将按顺序出现。

不要将counter定义为对象，而是使用Map，这将保留广告顺序：

function uniqueUnionSorted(arr) {
var counter = new Map();
for(var i=0; i<arr.length; i++) {
counter.set(arr[i], (counter.get(arr[i]) || 0) + 1);
}
// Spreading the Map will produce an array of pairs
var sortedNumbers = [...counter].sort(function(a,b) {
return b[1] - a[1]; // sort by count
}).map(a => a[0]); // only keep the values, not the counts
return sortedNumbers; // Map keys retain original type, so they remain numeric
}
arr = [1, 3, 2, 1, 5, 2, 1, 4]
console.log(uniqueUnionSorted(arr));

Answer 2

在计数器对象中，我们还可以保存每个元素的最低索引，以便我们可以将索引较低的元素保留在排序数组的早期。

function uniqueUnionSorted(arr) {
counter = {};
for(var i=0; i<arr.length; i++) {
if (arr[i] in counter) {
counter[arr[i]].count ++;
} else {
counter[arr[i]] = {'count' : 1, 'index' : i}; //save lowest index of element
}
}
sortedStrings = Object.keys(counter).sort(function(a,b) {
return counter[b].count - counter[a].count || counter[a].index - counter[b].index;
});
var sortedNumbers = sortedStrings.map(Number);
return sortedNumbers;
}
console.log(uniqueUnionSorted([1, 3, 2, 1, 5, 2, 1, 4]));

Answer 3

https://jsfiddle.net/anLrwwfa/4/

这是另一种方法，您可以使用 Set 对象、用于存储频率的对象以及用于保持原点不变的原始数组来执行此操作。它比目前流行的答案要长一点，但我正在写它，所以我想我会把我的帽子扔进戒指里。

function sortArr(arr) {
let uniqueValues = new Set();
let frequencies = new Object();
//add values to set object
arr.map((val) => uniqueValues.add(val));
//get frequencies of values
for (let val of uniqueValues) {
frequencies[val] = 0;
}
arr.map((val) => frequencies[val]++);
//sort by frequency, then sort by original placement in array
let sorted_arr = Array.from(uniqueValues).sort((a, b) => {
return frequencies[a] - frequencies[b];
}).sort((a, b) => {
return (frequencies[a] === frequencies[b]) ?
Array.from(uniqueValues).indexOf(a) - Array.from(uniqueValues).indexOf(b) :
b;
});
//return array
return sorted_arr;
};
sortArr([1, 3, 2, 1, 5, 2, 1, 4]);  //1,2,3,5,4

稍微编辑一下优化的代码

Answer 4

如果频率相等，可以添加一个附加条件，以实际排序在原始数组索引之后：

sortedStrings = Object.keys(counter).sort(function(a,b) {
return counter[b] - counter[a] || arr.indexOf(+a)-arr.indexOf(+b)
});

http://jsbin.com/zewulanozo/edit?console