从数组中获取唯一值的最快方法？

Question

我有一个这样的数组

students = [{name: 'Abbey', age: 25}, {name: 'Brian', age: 45},
            {name: 'Colin', age: 25}, {name: 'Dan', age: 78}]

我希望输出是；

uniqueAges = [45, 78]

需要明确的是，如果学生数组中出现多次的年龄值，我不希望在我的 uniqueAges 数组中任何具有该年龄的对象。 “Abbey”和“Colin”的年龄相同，所以他们都出局了。

我知道我可以这样做并运行uniqueAgeGetter(students)

   function uniqueAgeGetter(list){
   var listCopy = list.slice();
   var uniqueAges = list.slice();
   for (var i = list.length - 1; i >= 0; i--) {
        for (var j = listCopy.length - 1; j >= 0; j--) {
            if(listCopy[j].name !== list[i].name && 
                listCopy[j].age == list[i].age){
                  uniqueAges.splice(i, 1)
                }   
            }
    }
   console.log(uniqueAges)
   return uniqueAges
 }

但是是否可以在没有第二个循环的情况下做到这一点？我不是时间复杂度方面的专家，但我试图找出这个任务是否可能是 O(n)。

编辑： 我不是在问uniqueAgeGetter 是否被重写以更好地阅读或使用诸如 map、reduce 或 filter 之类的函数（因为我的理解是它们最终也是一个循环）。

我的问题是可以以降低时间复杂度的方式重构 uniqueAgeGetter 吗？可以只用一个循环完成吗？

谢谢。

Answer 1

这可以在O(n) 时间内完成，方法是计算一个年龄被看到的次数，并过滤掉计数超过一的年龄。

由于年龄有合理的限制，我们可以使用长度等于最大可能年龄的整数数组来存储年龄计数。在下面的示例中，我将可能的最大年龄设为舒适的200。

var students = [
  {name: 'Abbey', age: 25 }, 
  {name: 'Brian', age: 45 },
  {name: 'Colin', age: 25 }, 
  {name: 'Dan', age: 78 }
];

var studentAges = students.map(val => val.age);
var ageCounts = Array(200).fill(0);

studentAges.forEach(age => ageCounts[age] += 1);

var uniqueAges = studentAges.filter(age => ageCounts[age] == 1);

console.log(uniqueAges);

Answer 2

• 第一个想法，我们可以做两步：

  Step1：对数组进行排序

  -- 有很多算法可以做到这一点。据我所知，目前最佳算法的复杂度是 O(Nlog(N))，其中 N 是数组的数量。

  Step2：删除重复元素

  -- 这一步的复杂度是O(N) 因此，经过两步，复杂度为 O(N) + O(Nlog(N))。最后，复杂度是O(Nlog(N))

• 第二个想法

  这也有复杂性是 O(Nlog(N)) 但下次你想获得唯一年龄时它会是 O(N)。

  除了将数据保存在数组中之外，您还可以通过一些自定义在二叉搜索树中重建。这棵树中的这个节点将保存所有具有相同年龄的元素。

  第一次构建树的复杂度是 O(Nlog(N))

关于复杂度为O(N)的算法，目前我认为没有技术可以解决它。 :D

Answer 3

您可以使用reduce

第一个reduce是对数组进行汇总，并以年龄为key将其转换为对象。使用年龄作为键将更容易检查年龄是否已经存在。对象属性将有一个类似[2,true] 的数组值，其中第一个元素是年龄，第二个元素告诉年龄是否有重复项。使用Object.values 会将对象转换为数组。

第二个reduce是形成想要的输出。

let students = [{name: 'Abbey', age: 25 }, {name: 'Brian', age: 45 },{name: 'Colin', age: 25 }, {name: 'Dan', age: 78 }];

let uniqueAges = Object.values(students.reduce((c, v) => {
  if (c[v.age] === undefined) c[v.age] = [v.age, true];
  else c[v.age][1] = false;
  return c;
}, {})).reduce((c, v) => {
  if (v[1]) c.push(v[0]);
  return c;
}, []);

console.log(uniqueAges);

Answer 4

这是您可以做到的一种方法。我认为时间复杂度是O(n^2)，其中n 是原始数组中的元素数量，m 是输出数组中唯一元素的数量。

const students = [
  {name: 'Abbey', age: 25 }, 
  {name: 'Brian', age: 45 },
  {name: 'Colin', age: 25 }, 
  {name: 'Dan', age: 78 }
];

const uniqueStudents = students.map(val => val.age)
  .sort()
  .reduce((current, next) => {
    return current.length === 0 ? [].concat(current, next)
      : current[current.length - 1] !== next ? [].concat(current, next)
        : current.slice(0, -1);
  }, []);
  
console.log(uniqueStudents);

Answer 5

? 单次迭代最快的方式。

const students = [
  {name: `Abbey`, age: 25}, 
  {name: `Brian`, age: 45},
  {name: `Colin`, age: 25}, 
  {name: `Dan`, age: 78},
  {name: `Dan`, age: 25}
]

// no global variables
function unique(key) {
  const occurrences = {}
  const list = {}
  return (result, next, index, {length}) => {
    const value = next[key]
    if (list[value]) {
      occurrences[value] = value
    }
    else {
      list[value] = value
      result.push(value)
    }
    return index === length - 1 ? result.filter(v => !occurrences[v]) : result
  }
}

const uniqueNames = students.reduce(unique(`name`), [])
const uniqueAges = students.reduce(unique(`age`), [])

console.log(uniqueAges)