多列表高效比较方法咨询：5个有序列表的重复比较优化方案

Great question! Your current nested loop does a lot of redundant work—comparing every pair twice (like l0 vs l1 and then l1 vs l0) plus each list against itself. Let's fix this while keeping the order sensitivity you need (so no set() or Counter() tricks, which would ignore order).

Option 1: Avoid Redundant Comparisons with Upper Triangle Iteration #

Instead of looping through all i and k, only compare pairs where i < k (the upper triangle of the comparison matrix). Each pair gets checked exactly once, and we can store results to handle reverse lookups quickly.

l0 = [1,2,3,4,5]
l1 = [3,4,5,6,7]
l2 = [1,2,3,4,5]
l3 = [3,3,3,5,6]
l4 = [1,2,3,4,5]

lists = [l0, l1, l2, l3, l4]
comparison_cache = {}

# Only compare each unique pair once (i < k)
for i in range(len(lists)):
    # Uncomment below if you want to skip self-comparison
    # comparison_cache[(i, i)] = True
    for k in range(i + 1, len(lists)):
        is_equal = lists[i] == lists[k]
        # Store both directions for quick lookup later
        comparison_cache[(i, k)] = is_equal
        comparison_cache[(k, i)] = is_equal
        print(f"l{i} is {'equal to' if is_equal else 'not equal to'} l{k}")

# Example: Check any pair later without re-comparing
print(f"l1 vs l0: {'equal' if comparison_cache[(1, 0)] else 'not equal'}")

This cuts the number of comparisons from n² to n(n-1)/2—a huge saving when you have many lists.

Option 2: Group Identical Lists with Order-Preserving Fingerprints #

For even better efficiency (especially with large numbers of lists), convert each list to a tuple (which is hashable and preserves order) and group lists by their tuple "fingerprint". This way, you only need to process each list once, then generate equal pairs from the groups.

l0 = [1,2,3,4,5]
l1 = [3,4,5,6,7]
l2 = [1,2,3,4,5]
l3 = [3,3,3,5,6]
l4 = [1,2,3,4,5]

lists = [l0, l1, l2, l3, l4]
# Map tuple fingerprints to list indices
list_groups = {}
for idx, lst in enumerate(lists):
    lst_fingerprint = tuple(lst)
    if lst_fingerprint not in list_groups:
        list_groups[lst_fingerprint] = []
    list_groups[lst_fingerprint].append(idx)

# Print all equal pairs
for group_indices in list_groups.values():
    # Generate all unique pairs within the group
    for i in range(len(group_indices)):
        for k in range(i + 1, len(group_indices)):
            print(f"l{group_indices[i]} is equal to l{group_indices[k]}")

# Check if two specific lists are equal
def lists_are_equal(idx1, idx2):
    return tuple(lists[idx1]) == tuple(lists[idx2])

print(f"l0 equals l2? {lists_are_equal(0, 2)}")  # Outputs True

This approach runs in O(n*m) time (where n is the number of lists, m is the average length of each list) compared to O(n²*m) for the nested loop—way faster as n grows.

Key Notes #

• If you need to report all pairs (including non-equal ones), use Option 1 with the cache to avoid re-computing.
• If you only care about finding which lists are identical, Option 2 is the most efficient.
• Both methods fully preserve order, so they fit your requirement perfectly.

内容的提问来源于stack exchange，提问作者monte