如何在对数时间内检查具有相等值的对象是否在容器中

Question

我想以对数时间查看容器中是否有相等值的对象。

我想拥有以下功能：

const a = [];

const el1 = {name: 'name1', directive: 'directive1'};
const el2 = {name: 'name2', directive: 'directive2'};
const el3 = {name: 'name3', directive: 'directive3'};
const b = {name: 'name1', directive: 'directive1'};

a.push(el1);
a.push(el2);
a.push(el3);


if(a.some(el => (el.name === b.name && el.directive === b.directive ))) {
  console.log("YES!");
} else {
  console.log("NO!");
}

这给了我想要的结果。但是，这是 O(N) 时间。

const s = new Set();

const el1 = {name: 'name1', directive: 'directive1'};
const el2 = {name: 'name2', directive: 'directive2'};
const el3 = {name: 'name3', directive: 'directive3'};
const b = {name: 'name1', directive: 'directive1'};

s.add(el1);
s.add(el2);
s.add(el3);

if(s.has(b)) {
  console.log("YES!");
} else {
  console.log("NO!");
}

这是 O(logN)，但结果不是我想要的。

那么我可以使用哪种 Javascript 数据结构来在上面的代码中打印 YES 并且复杂度为 O(logN)？ （我不想自己实现数据结构）

Answer 1

您可以使用以名称为键的 Map，其中对应的值是一组指令：

const elements = [
    {name: 'name1', directive: 'directive1'},
    {name: 'name2', directive: 'directive2'},
    {name: 'name3', directive: 'directive3'}
];

const map = new Map(elements.map(({name}) => [name, new Set]));
elements.forEach(({name, directive}) => map.get(name).add(directive));

const b = {name: 'name1', directive: 'directive1'};

if (map.has(b.name) && map.get(b.name).has(b.directive)) {
    console.log("YES!");
} else {
    console.log("NO!");
}

Answer 2

假设：数组a 按字典顺序排序，即a[i]<a[j] 无论何时a[i].name<a[j].name || (a[i].name==a[j].name && a[i].description<a[j].description))

这是一个具有对数复杂度的二分搜索：

const a = [];
for (i = 0; i < 100000; i++) {
  si = String(i);
  el = {
    name: 'name' + si,
    directive: 'directive' + si
  };
  a.push(el);
}

const b = {
  name: 'name70000',
  directive: 'directive70000'
};


var c = 0; // counter 

// binary search
function binary_search(a, b) {
  c++;
  var l = 0;
  var r = a.length - 1;
  if (l > r) {
    return false;
  }
  m = Math.floor((l + r) / 2);
  if ((a[m].name < b.name) || (a[m].name == b.name && a[m].directive < b.directive)) {
    return binary_search(a.slice(m + 1), b);
  } else if ((a[m].name > b.name) || (a[m].name == b.name && a[m].directive > b.directive)) {
    return binary_search(a.slice(0, m), b);
  } else {
    return true;
  }
}



found = binary_search(a, b);
console.log(found, "in " + String(c) + " steps");

Answer 3

我们可以使用Array 作为数据结构。考虑到我们可以使用递归对数时间函数，通过确定父字段部分的端点并递归来沿多个维度进行排序（或查找插入/删除的位置）。

假设我们的维度是脚手架：name -> directive -> third_property

首先按照name对数组进行排序。现在找到log n 时间中的每个name 部分，并根据directive 仅对该部分进行快速排序，third_property 类似。然后找到一个元素，使用类似的二分搜索，首先找到name属性的范围，然后在directive的范围内使用二分搜索，依此类推。

或者通过为每个可以排序的元素创建一个键并进行二进制搜索来绕过所有这些：element.key = element.name + element.directive :)

Answer 4

不要看这个答案的负分。使用它并享受它。 O(logN).?

---

它返回 false，因为它们（el1 和 b）是不同的对象引用。您可以通过el1 填写b，但如果您想要一种简单的方法来使用O(logN) 进行搜索，您可以使用我的以下代码：

var orderObj = function(unordered){
   const ordered = {};
   Object.keys(unordered).sort().forEach(function(key) {
       ordered[key] = unordered[key];
    });
    return ordered;
}
Set.prototype.addIt = function(item){s.add(JSON.stringify(orderObj(item)));}
Set.prototype.hasIt = function(item){return s.has(JSON.stringify(orderObj(item)));}
    
//-------------------------------------

const s = new Set();

const el1 = {name: 'name1', directive: 'directive1'};
const el2 = {name: 'name2', directive: 'directive2'};
const el3 = {name: 'name3', directive: 'directive3'};

const b = {name: 'name1', directive: 'directive1'};
const c = {directive: 'directive3', name: 'name3'};

s.addIt(el1);
s.addIt(el2);
s.addIt(el3);

s.hasIt(b)
 ?console.log("YES!")
 :console.log("NO!");

s.hasIt(c)
 ?console.log("YES!")
 :console.log("NO!");

---

更新：

我更新了我的答案，现在它支持不同顺序的对象。正如您在上面的示例中看到的那样，c 与 el3 的顺序不同，但脚本返回 Yes 结果；）