二进制搜索速度较慢，我做错了什么？

Question

编辑：所以看起来这是正常行为，所以任何人都可以推荐一种更快的方法来完成这些众多的交叉路口吗？

所以我的问题是这样的。我有 8000 个列表（每个列表中的字符串）。对于每个列表（大小从 50 到 400），我将其与其他所有列表进行比较，并根据交叉点数执行计算。所以我会做的

list1(intersect)list1= number

list1(intersect)list2= number

list1(intersect)list888= number

我对每个列表都这样做。以前，我有 HashList，我的代码基本上是这样的：（好吧，我实际上是在搜索对象的属性，所以我 不得不稍微修改一下代码，但基本上是这样的：

下面有我的两个版本，但如果有人知道更快，请告诉我！

遍历AllLists，获取每个列表，从list1开始，然后这样做：

foreach (List list in AllLists)
{
    if (list1_length < list_length) //just a check to so I'm looping through the                  
                                    //smaller list
    {
        foreach (string word in list1)
        {
            if (block.generator_list.Contains(word))
            {
                //simple integer count
            }
        }
    }
// a little more code, but the same, but looping through the other list if it's smaller/bigger

然后我将列表变成常规列表，并应用 Sort()，这将我的代码更改为

foreach (List list in AllLists)
{
    if (list1_length < list_length) //just a check to so I'm looping through the                  
                                    //smaller list
    {
        for (int i = 0; i < list1_length; i++)
        {
            var test = list.BinarySearch(list1[i]);
            if (test > -1)
            {
                //simple integer count
            }
        }
    }

第一个版本大约需要 6 秒，另一个需要 20 多秒（我只是停在那里，否则需要一分钟以上！！！）（这是数据的一小部分）

我确定某处存在严重错误，但我找不到。

Answer 1

我已经尝试了三种不同的方法来实现这一点（假设我正确理解了这个问题）。请注意，我使用HashSet<int> 是为了更轻松地生成随机输入。 设置：

List<HashSet<int>> allSets = new List<HashSet<int>>();
Random rand = new Random();
for(int i = 0; i < 8000; ++i) {
    HashSet<int> ints = new HashSet<int>();
    for(int j = 0; j < rand.Next(50, 400); ++j) {
        ints.Add(rand.Next(0, 1000));
    }
    allSets.Add(ints);
}

我检查的三个方法（代码是在内循环中运行的）：

循环：

请注意，您的代码中会出现重复的结果（将集合 A 与集合 B 相交，然后将集合 B 与集合 A 相交）。 由于您正在执行列表长度检查，它不会影响您的性能。但是这样迭代更清晰。

for(int i = 0; i < allSets.Count; ++i) {
    for(int j = i + 1; j < allSets.Count; ++j) {

    }
}

第一种方法：

使用IEnumerable.Intersect() 获取与其他列表的交集，并检查IEnumerable.Count() 获取交集的大小。

var intersect = allSets[i].Intersect(allSets[j]);
count = intersect.Count();

这是最慢的，平均为 177 秒

第二种方法：

克隆了我正在相交的两个集合中较小的集合，然后使用ISet.IntersectWith() 并检查了结果集合Count。

HashSet<int> intersect;
HashSet<int> intersectWith;
        if(allSets[i].Count < allSets[j].Count) {
            intersect = new HashSet<int>(allSets[i]);
            intersectWith = allSets[j];
        } else {
            intersect = new HashSet<int>(allSets[j]);
            intersectWith = allSets[i];
        }
        intersect.IntersectWith(intersectWith);
        count = intersect.Count;
    }
}

这个稍微快一点，平均 154 秒

第三种方法：

做了一些与你在较短的集合上迭代并在较长的集合上检查ISet.Contains所做的非常相似的事情。

for(int i = 0; i < allSets.Count; ++i) {
    for(int j = i + 1; j < allSets.Count; ++j) {
        count = 0;
        if(allSets[i].Count < allSets[j].Count) {
            loopingSet = allSets[i];
            containsSet = allSets[j];
        } else {
            loopingSet = allSets[j];
            containsSet = allSets[i];
        }
        foreach(int k in loopingSet) {
            if(containsSet.Contains(k)) {
                ++count;
            }
        }
    }
}

这种方法是迄今为止最快的（如预期的那样），平均为 66 秒

结论

您使用的方法是这三种方法中最快的。我当然想不出更快的单线程方式来做到这一点。也许有更好的并发解决方案。

Answer 2

我发现在迭代/搜索任何类型的集合时，最重要的考虑因素之一是非常谨慎地选择集合类型。为您的目的遍历一个正常的集合并不是最理想的。尝试使用类似的东西：

System.Collections.Generic.HashSet<T>

在迭代两个较短的列表时使用 Contains() 方法（正如您提到的您已经在做的那样）应该提供接近 O(1) 的性能，与通用 Dictionary 类型中的键查找相同。