获取 List<object> 之间差异的最快方法

Question

我正在开发一个程序，例如，它能够找到文件夹之间的文件差异。我制作了一种遍历给定文件夹的文件夹结构并为每个子文件夹构建树的方法。每个节点都包含一个文件列表，即该文件夹中的文件。每个节点都有一定数量的子节点，对应于该文件夹中的文件夹。

现在的问题是找到存在于一棵树中的文件，而不是存在于另一棵树中的文件。我有一个方法：“private List Diff(Node index1, Node index2)”，应该这样做。但问题是我比较树木的方式。比较两棵树需要大量时间 - 当每个输入节点包含大约 70,000 个文件时，Diff 方法大约需要 3-5 分钟才能完成。

我目前正在这样做：

private List<MyFile> Diff(Node index1, Node index2)
    {
        List<MyFile> DifferentFiles = new List<MyFile>();

        List<MyFile> Index1Files = FindFiles(index1);
        List<MyFile> Index2Files = FindFiles(index2);

        List<MyFile> JoinedList = new List<MyFile>();
        JoinedList.AddRange(Index1Files);
        JoinedList.AddRange(Index2Files);
        List<MyFile> JoinedListCopy = new List<MyFile>();
        JoinedListCopy.AddRange(JoinedList);
        List<string> ChecksumList = new List<string>();

        foreach (MyFile m in JoinedList)
        {

            if (ChecksumList.Contains(m.Checksum))
            {
                JoinedListCopy.RemoveAll(x => x.Checksum == m.Checksum);
            }
            else
            {
                ChecksumList.Add(m.Checksum);
            }
        }

        return JoinedListCopy;
    }

Node 类看起来像这样：

class Node
{
    private string _Dir;
    private Node _Parent;
    private List<Node> _Children;
    private List<MyFile> _Files;
}

Answer 1

您可以将所有校验和放入HashSet 中，而不是通过List 结构进行大量搜索（这很慢），这样可以更更有效地搜索。 p>

private List<MyFile> Diff(Node index1, Node index2)
{
    var Index1Files = FindFiles(index1);
    var Index2Files = FindFiles(index2);

    //this is all of the files in both
    var intersection = new HashSet<string>(Index1Files.Select(file => file.Checksum)
         .Intersect(Index2Files.Select(file => file.Checksum)));

    return Index1Files.Concat(Index2Files)
        .Where(file => !intersection.Contains(file.Checksum))
        .ToList();
}

Answer 2

怎么样：

    public static IEnumerable<MyFile> FindUniqueFiles(IEnumerable<MyFile> index1, IEnumerable<MyFile> index2)
    {
        HashSet<string> hash = new HashSet<string>();

        foreach (var file in index1.Concat(index2))
        {
            if (!hash.Add(file.Checksum))
            {
                hash.Remove(file.Checksum);
            }
        }

        return index1.Concat(index2).Where(file => hash.Contains(file.Checksum));
    }

这将在假设一棵树不包含重复项的情况下起作用。 Servy 的答案适用于所有情况。

Answer 3

您是否为树中的每个元素保留整个 FileSystemObject？如果是这样，我认为您的内存开销将是巨大的。为什么不直接使用文件名或校验和并将其放入列表中，然后对其进行比较？

Answer 4

我可以看到这不仅仅是一个“独特”的功能，您真正要寻找的是在 JoinedListCopy 集合中只存在一次的所有实例，而不仅仅是 JoinedListCopy 集合中所有不同实例的列表。

Servy 有一个很好的答案，我会建议一种不同的方法，它利用 linq 的一些更有趣的功能，或者至少我觉得它们很有趣。

var diff_Files = (from a in Index1Files
                 join b in Index2Files
                 on a.CheckSum equals b.CheckSum
                 where !(Index2Files.Contains(a) || Index1Files.Contains(b))).ToList()

另一种构建“位置”的方法可能会更好，文件实例实际上可能并不相同，就代码相等而言......

where !(Index2Files.Any(c=>c.Checksum == a.Checksum) || Index1Files.Any(c=>c.Checksum == b.Checksum))

查看单个校验和，而不是整个文件对象实例。

基本策略本质上与您已经在做的完全一样，只是效率更高一点：加入集合并相互过滤，以确保您只获得唯一的条目。

另一种方法是使用 linq 中的计数功能

var diff_Files = JoinedListCopy.Where(a=> JoinedListCopy.Count(b=>b.CheckSum == a.CheckSum) == 1).ToList();

嵌套 linq 并不总是世界上最有效的东西，但它应该工作得相当好，让所有实例只发生一次。实际上，我最喜欢这种方法，把事情搞砸的可能性最小，但我首先使用的连接可能更有效。