给定一个对象A和一个对象L列表，如何在不测试所有情况的情况下查找L上的哪些对象是A的克隆？

Question

Using JavaScript notation:

A = {color:'red',size:8,type:'circle'};

L = [{color:'gray',size:15,type:'square'},
     {color:'pink',size:4,type:'triangle'},
     {color:'red',size:8,type:'circle'},
     {color:'red',size:12,type:'circle'},
     {color:'blue',size:10,type:'rectangle'}];

The answer for this case would be 2, because L[2] is identic to A. You could find the answer in O(n) by testing each possibility. What is a representation/algorithm that allows finding that answer faster?

Answer 1

I would just create a HashMap and put all objects into the HashMap. Also we would need to define a hash function which is function of data in object (something similar to overriding Object.hashcode() in java)

Suppose given array L is [B, C, D] where B, C and D are objects. Then HashMap would be {B=>1, C=>2, D=>3}. Now suppose D is copy of A. So we would just lookup A in this map and get the answer. Also as suggested by Eric P in comment, we would need to keep the hashmap updated with respect to any change in array L. This also can be done in O(1) for every operation in array L.

Cost of Looking up an object in the HashMap is O(1). So we can achieve O(1) complexity.

Answer 2

I think it's not possible to do it faster than O(n) with your preconditions. It's possible to find element in O(logn) using binary search, but:

• A) you need elements with one variable to compare
• B) sorted list by that variable

Maybe with some technics (ordering, skip lists, etc.) you can find answer faster than N iterations, but the worst case is O(n)

Answer 3

由于目标是查找所有属于A的克隆的对象，因此必须至少测试每个对象一次，以确定它是否是A的克隆，因此最小测试数为N。一次通过列表并测试每个对象执行N次测试，因此由于此方法是最少的测试次数，因此它是一种最佳方法。

Answer 4

first, I assume, that you are talking about array, not list. the word 'list' is reserved for specific type of data structures, that has O(n) indexing comlexity, so meantime for any search in it is at least linear.

for unsorted array, the only algorithm is full scan with linear time. However, if array is sorted, you can use binary or interpolating search to get better time.

The problem with sorted arrays is that they have linear insert time. No good. So if you wish to update your set much and both update and search times are important, you should search for optimized container, that in c++ and haskell is called Set ( set template in set header and Data.Set module in containers package respectively). I dunno if there is any in JS.