现在有三个选项 - 前两个选项比较一般, 因为它们不依赖正在排序的 < code> millionIntegerList (原未指明)。 在大列表 < em> is 已经排序的情况下, 第三种选项更可取 。

<强 > 备选1

使用LINQ(LINQ),

var common = MillionIntegerList.Intersect(TwoThousandIntegerList).ToList();

这将在内部使用 HashSet<int> 所建的 two Thousand IntegerList , 然后在其中查找 millionIntegerList 的每一个元素 - 这将比每次翻遍 two ThousandIntegerList 整个 有效得多。

如果您只想要非黑名单,您需要:

var valid = MillionIntegerList.Except(TwoThousandIntegerList).ToList();

请注意,如果您只需要一次复制结果, 您就应该删除 < code> ToList 调用 < code> to list 调用 - 我将它包括在内, 以便实现结果, 从而可以便宜地进行多次检查。 如果您只是重复使用, 除 < / code > 外, < code > 或 < code > 的返回值只会 < em> 流出结果, 从而在记忆使用方面更便宜。

<强 > 备选2

如果您不想依赖 LINQ 对对象的实施细节, 但是您仍然想要基于散列的方法 :

var hashSet = new HashSet<int>(TwoThousandIntegerList);
hashSet.IntersectWith(MillionIntegerList);
// Now use hashSet

<强 > 备选3

使用对大名单进行分类的做法肯定是有益的。

假设您不介意先对黑名单进行排序, 您可以写出类似( 未测试的)流( 和一般目的) 执行 :

// Note: to use this, you d need to make sure that *both* sequences are sorted.
// You could either sort TwoThousandIntegerList in place, or use LINQ s OrderBy
// method.

public IEnumerable<T> SortedIntersect<T>(this IEnumerable<T> first,
    IEnumerable<T> second) where T : IComparable<T>
{
    using (var firstIterator = first.GetEnumerator())
    {
        if (!firstIterator.MoveNext())
        {
            yield break;
        }

        using (var secondIterator = second.GetEnumerator())
        {
            if (!secondIterator.MoveNext())
            {
                yield break;
            }
            T firstValue = firstIterator.Current;
            T secondValue = secondIterator.Current;

            while (true)
            {
                int comparison = firstValue.CompareTo(secondValue);
                if (comparison == 0) // firstValue == secondValue
                {
                    yield return firstValue;
                }
                else if (comparison < 0) // firstValue < secondValue
                {
                    if (!firstIterator.MoveNext())
                    {
                        yield break;
                    }
                    firstValue = firstIterator.Current;
                }
                else // firstValue > secondValue
                {
                    if (!secondIterator.MoveNext())
                    {
                        yield break;
                    }
                    secondValue = secondIterator.Current;
                }  
            }                
        }
    }
}

(如果您想要使用 Icomparer<T> ,而不是以T为类比,您可以使用 Icomparer<T> 。 )

由于大列表已经排序。 您可能会通过排序小列表( 非常快速) 取得最佳结果, 然后进行线性合并 。 您只需要查看一次大列表( 和小列表) 中的每个项目, 不需要在背景中创建 Hashbable 。

见"http://en.wikipedia.org/wiki/Mege_sort">merge 函数 合并Sort的一部分,以了解如何做到这一点。

你所需要的是无数的。在我看来,除了方法(数字,数字)之外

这里请 ""http://msdn.microsoft.com/en-us/library/bb300779.aspx" rel="noreferr" >http://msdn.microsoft.com/en-us/library/bb300779.aspx

您的方法需要 O(n*n) 时间。 考虑这些优化 :

• (1)(1)

  如果您的整数不太大, 您可以使用布布数组( 例如, 如果最大可能的整数是1000000, 请使用布 [ ] b = 新布 [ 100000] 。 现在要在黑名单中添加一个数字 K, 使用 b[ K] = true。 检查是微不足道的。 这在 O( n) 中有效 。 您也可以使用 BitAray 。

• 2) 2)

  整数可能足够大 。 使用二进搜索树来存储黑列表( 例如 ScortedSet) 。 它有 O( logN) 插入和检索时间 。 因此, 全部是 O( N* logN) 。 语法与列表( Add( int) K, 包含( int K) ) 相同, 重复被忽略 。

I think the best solution is to use a Bloom filter and it case the Bloom filter says an element may be in the blacklist, just check if is not a false positive (which can be done in O(Log(n)) if the blacklist is sorted). This solution is time efficient and uses almost no additional space which makes it far better than using a hashset.

这是Google在Chrome黑名单中使用的解决方案。

如何在较长的列表上进行二进制搜索, 因为它已经分类了 。

foreach(integer blacklisted in TwoThousandIntegerList)
{
    integer i  = MillionIntegerList.binarySearch(blacklisted)
    if(i==blacklisted){
          //Do your stuff
    } 
}

此解决方案只花费 O( mlog n) 时间, m 是小列表的大小, n 是长列表的大小 。 < enference > Caveat: 此解决方案假设 millionIntegerList 没有重复值 。

foreach(integer blacklisted in TwoThousandIntegerList)
{
    integer index = MillionIntegerList.binarySearch(blacklisted)
    //Find the index of the first occurrence of blacklisted value
    while(index > 0 && MillionIntegerList[index - 1].value == blacklisted){
          --index;
    }
    while(MillionIntegerList[index].value == blacklisted){
          //Do your stuff
          ++index;
    } 
}