如何有效地比较两个无序列表（不是集合）？

Question

a = [1, 2, 3, 1, 2, 3]
b = [3, 2, 1, 3, 2, 1]

a & b 应该被认为是相等的，因为它们具有完全相同的元素，只是顺序不同。

问题是，我的实际列表将包含对象（我的 class 实例），而不是整数。

Answer 1

O(n) ： Counter()方法是最好的（如果您的对象是可散列的）：

def compare(s, t):
    return Counter(s) == Counter(t)

O(n log n) ： sorted()方法是次佳的（如果您的对象是可订购的）：

def compare(s, t):
    return sorted(s) == sorted(t)

O(n * n) ：如果对象既不是可散列的，也不是可排序的，您可以使用相等：

def compare(s, t):
    t = list(t)   # make a mutable copy
    try:
        for elem in s:
            t.remove(elem)
    except ValueError:
        return False
    return not t

Answer 2

您可以对两者进行排序：

sorted(a) == sorted(b)

计数排序也可能更有效（但它要求对象是可散列的）。

>>> from collections import Counter
>>> a = [1, 2, 3, 1, 2, 3]
>>> b = [3, 2, 1, 3, 2, 1]
>>> print (Counter(a) == Counter(b))
True

Answer 3

如果您知道这些项目始终是可散列的，则可以使用 O(n) 的Counter() )
如果您知道这些项目始终是可排序的，则可以使用sorted() ，即 O(n log n)

在一般情况下，您不能依赖能够排序或拥有元素，因此您需要像这样的后备，不幸的是 O(n^2)

len(a)==len(b) and all(a.count(i)==b.count(i) for i in a)

Answer 4

如果您必须在测试中执行此操作： https ://docs.python.org/3.5/library/unittest.html#unittest.TestCase.assertCountEqual

assertCountEqual(first, second, msg=None)

测试该序列首先包含与第二个相同的元素，无论它们的顺序如何。 如果不这样做，将生成列出序列之间差异的错误消息。

比较第一个和第二个时不会忽略重复的元素。 它验证每个元素在两个序列中是否具有相同的计数。 等价于：assertEqual(Counter(list(first)), Counter(list(second))) 但也适用于不可散列对象的序列。

3.2 版中的新功能。

或在 2.7 中： https ://docs.python.org/2.7/library/unittest.html#unittest.TestCase.assertItemsEqual

在测试之外，我会推荐Counter方法。

Answer 5

如果要在测试上下文中执行比较，请使用assertCountEqual(a, b) ( py>=3.2 ) 和assertItemsEqual(a, b) ( 2.7<=py<3.2 )。

也适用于不可散列对象的序列。

Answer 6

最好的方法是对列表进行排序并进行比较。 （使用Counter不适用于不可散列的对象。）这对于整数来说很简单：

sorted(a) == sorted(b)

对于任意对象，它会变得有点棘手。 如果您关心对象标识，即两个列表中是否有相同的对象，您可以使用id()函数作为排序键。

sorted(a, key=id) == sorted(b, key==id)

（在 Python 2.x 中，您实际上不需要key=参数，因为您可以将任何对象与任何对象进行比较。排序是任意但稳定的，因此它可以很好地用于此目的；不管是什么顺序对象在, 只是两个列表的顺序相同. 但是, 在 Python 3 中, 在许多情况下不允许比较不同类型的对象 - 例如, 你不能将字符串与整数进行比较 - 所以如果你愿意有各种类型的对象，最好显式使用对象的 ID。）

另一方面，如果要按值比较列表中的对象，首先需要定义“值”对对象的含义。 然后你需要一些方法来提供它作为一个键（对于 Python 3，作为一个一致的类型）。 适用于许多任意对象的一种潜在方法是按它们的repr()排序。 当然，这可能会浪费大量额外的时间和内存来为大型列表等构建repr()字符串。

sorted(a, key=repr) == sorted(b, key==repr)

如果对象都是您自己的类型，您可以在它们上定义__lt__()以便对象知道如何将自己与其他对象进行比较。 然后你可以对它们进行排序，而不用担心key=参数。 当然你也可以定义__hash__()并使用Counter ，这样会更快。

Answer 7

如果列表包含不可散列的项目（例如对象列表），您可能可以使用Counter 类和 id() 函数，例如：

from collections import Counter
...
if Counter(map(id,a)) == Counter(map(id,b)):
    print("Lists a and b contain the same objects")

Answer 8

我希望下面的代码可能适用于您的情况：-

if ((len(a) == len(b)) and
   (all(i in a for i in b))):
    print 'True'
else:
    print 'False'

这将确保列表a和b中的所有元素都相同，无论它们的顺序是否相同。

为了更好地理解，请参阅我在这个问题中的回答

Answer 9

让 a,b 列出

def ass_equal(a,b):
try:
    map(lambda x: a.pop(a.index(x)), b) # try to remove all the elements of b from a, on fail, throw exception
    if len(a) == 0: # if a is empty, means that b has removed them all
        return True 
except:
    return False # b failed to remove some items from a

无需使它们可散列或对它们进行排序。

Answer 10

您可以编写自己的函数来比较列表。

让我们得到两个列表。

list_1=['John', 'Doe'] 
list_2=['Doe','Joe']

首先，我们定义一个空字典，统计列表项并写入字典。

def count_list(list_items):
    empty_dict={}
    for list_item in list_items:
        list_item=list_item.strip()
        if list_item not in empty_dict:
            empty_dict[list_item]=1
        else:
            empty_dict[list_item]+=1
    return empty_dict


        

之后，我们将使用以下函数比较两个列表。

def compare_list(list_1, list_2):
    if count_list(list_1)==count_list(list_2):
        return True
    return False
compare_list(list_1,list_2)

Answer 11

from collections import defaultdict

def _list_eq(a: list, b: list) -> bool:
    if len(a) != len(b):
        return False
    b_set = set(b)
    a_map = defaultdict(lambda: 0)
    b_map = defaultdict(lambda: 0)
    for item1, item2 in zip(a, b):
        if item1 not in b_set:
            return False
        a_map[item1] += 1
        b_map[item2] += 1
    return a_map == b_map

如果数据高度无序，排序可能会非常慢（当项目具有某种程度的排序时，timsort 会特别好）。 对两者进行排序还需要对两个列表进行完全迭代。

与其改变一个列表，不如分配一个集合并进行左-->右成员资格检查，同时记录沿途存在的每个项目的数量：

• 如果两个列表的长度不同，您可以短路并立即返回False 。
• 如果您点击列表a中不在列表b中的任何项目，您可以返回False
• 如果您通过所有项目，那么您可以比较a_map和b_map的值以找出它们是否匹配。

这允许您在迭代两个列表之前很久就在许多情况下短路。

Answer 12

插入这个：

def lists_equal(l1: list, l2: list) -> bool:
    """

    import collections
    compare = lambda x, y: collections.Counter(x) == collections.Counter(y)
    ref:
        - https://stackoverflow.com/questions/9623114/check-if-two-unordered-lists-are-equal
        - https://stackoverflow.com/questions/7828867/how-to-efficiently-compare-two-unordered-lists-not-sets
    """
    compare = lambda x, y: collections.Counter(x) == collections.Counter(y)
    set_comp = set(l1) == set(l2)  # removes duplicates, so returns true when not sometimes :(
    multiset_comp = compare(l1, l2)  # approximates multiset
    return set_comp and multiset_comp  #set_comp is gere in case the compare function doesn't work