使用IEqualityComparer比较含重复元素的无序列表是否相等

嘿，这需求我太懂了！要实现一个IEqualityComparer<List<T>>，用来判断两个列表是不是包含完全相同的元素，且每个元素的出现次数也完全一致，完全不管元素顺序对吧？这就给你整一个靠谱的实现：

首先明确核心规则：两个列表相等的条件是——元素总数相同，每个元素的出现次数完全匹配，顺序不影响。比如{1,2,2}和{2,1,2}是相等的，但{1,2,2}和{2,1,1}就不相等，因为2和1的出现次数对不上。

实现思路 #

核心就是用字典统计元素的出现频次：

• 先判断两个列表的长度，长度不一样直接返回false（总数都不同，频次肯定匹配不了）
• 统计其中一个列表的元素频次
• 遍历另一个列表，逐一扣减对应元素的频次计数，遇到不存在的元素或者频次不够就返回false
• 最后如果频次字典被清空，说明完全匹配

完整代码实现 #

using System;
using System.Collections.Generic;
using System.Linq;

public class ListFrequencyEqualityComparer<T> : IEqualityComparer<List<T>>
{
    private readonly IEqualityComparer<T> _elementComparer;

    // 支持传入自定义元素比较器，默认用类型自带的EqualityComparer
    public ListFrequencyEqualityComparer(IEqualityComparer<T> elementComparer = null)
    {
        _elementComparer = elementComparer ?? EqualityComparer<T>.Default;
    }

    public bool Equals(List<T> x, List<T> y)
    {
        // 处理null边界情况
        if (ReferenceEquals(x, y)) return true;
        if (x is null || y is null) return false;
        // 长度不同直接不相等
        if (x.Count != y.Count) return false;

        // 统计第一个列表的元素出现次数
        var frequencyMap = x.GroupBy(item => item, _elementComparer)
                            .ToDictionary(g => g.Key, g => g.Count(), _elementComparer);

        // 遍历第二个列表，逐一校验并扣减频次
        foreach (var item in y)
        {
            if (!frequencyMap.TryGetValue(item, out int remainingCount))
                return false; // 第二个列表有第一个列表没有的元素

            if (remainingCount == 1)
                frequencyMap.Remove(item);
            else
                frequencyMap[item] = remainingCount - 1;
        }

        // 所有元素频次都匹配的话，字典应该是空的
        return frequencyMap.Count == 0;
    }

    public int GetHashCode(List<T> obj)
    {
        if (obj is null) return 0;

        // 计算稳定的哈希码：基于元素和其频次的组合，排序后计算保证顺序不影响结果
        int hashCode = 17;
        var frequencyGroups = obj.GroupBy(item => item, _elementComparer)
                                 .OrderBy(g => g.Key, _elementComparer);

        foreach (var group in frequencyGroups)
        {
            hashCode = hashCode * 31 + _elementComparer.GetHashCode(group.Key);
            hashCode = hashCode * 31 + group.Count().GetHashCode();
        }

        return hashCode;
    }
}

怎么用？看示例 #

var listA = new List<int> { 1, 2, 2 };
var listB = new List<int> { 2, 1, 2 };
var listC = new List<int> { 2, 1, 1 };

var comparer = new ListFrequencyEqualityComparer<int>();

Console.WriteLine(comparer.Equals(listA, listB)); // 输出 True
Console.WriteLine(comparer.Equals(listA, listC)); // 输出 False

一些值得注意的细节 #

• 支持自定义元素比较：比如你要比较字符串列表，想忽略大小写，就传入StringComparer.OrdinalIgnoreCase作为构造参数就行
• 哈希码的正确性：GetHashCode里对元素分组排序后计算哈希，保证不同顺序的相同频次列表得到相同的哈希码，符合IEqualityComparer的规范（毕竟哈希码相等是相等的必要条件）
• 边界情况处理：完美处理了null列表、空列表、单元素列表这些特殊情况
• 性能还算不错：先判断长度的小优化能快速排除很多不相等的情况，避免不必要的统计操作

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