4

我想找出字典查找和数组的二进制搜索查找之间的权衡点。我期待字典的恒定时间查找，以及二进制搜索的对数时间查找，具体取决于集合的大小，对于较小的集合，二进制搜索的性能更好。

然而，当我看到以下结果时，我感到很惊讶： 二进制搜索呈指数增长，哈希查找增长缓慢

我很惊讶： 1. 二分搜索起初呈对数增长，然后增长得更快。2. 哈希起初相当一致，但随后也开始缓慢增长。3. 二分查找永远比散列查找好。下面是我的代码。我做错了什么？

class Program
{
    static void Main(string[] args)
    {
        var r = new Random();
        var targets = Enumerable.Range(0, 1000 * 1000).Select(_ => r.Next(int.MaxValue)).ToList();

        for (int totalCount = 1; totalCount < 1000*1000*10; totalCount*=2)
        {
            var a = Enumerable.Range(0, totalCount).Select(_ => r.Next(int.MaxValue)).Distinct().Select(v => new thing(v)).OrderBy(t => t.value).ToArray();
            var d = a.ToDictionary(t => t.value);

            var watch = new System.Diagnostics.Stopwatch();

            {
                watch.Start();
                var found = targets.Select(t => BinarySearch(t, a)).Where(t => t != null).Count();
                watch.Stop();
                Console.WriteLine(string.Format("found {0} things out of {2} in {1} ms with binary search", found, watch.ElapsedMilliseconds, a.Length));
            }
            {
                watch.Restart();
                var found =  targets.Select(t => HashSearch(t, d)).Where(t => t != null).Count();
                watch.Stop();
                Console.WriteLine(string.Format("found {0} things out of {2} in {1} ms with hash search", found, watch.ElapsedMilliseconds, d.Keys.Count));
            }
        }
        Console.ReadLine();
    }

    static thing HashSearch(int needle, Dictionary<int, thing> hash)
    {
        if (!hash.ContainsKey(needle))
            return null;
        return hash[needle];
    }

    static thing BinarySearch(int needle, thing[] sortedHaystack)
    {
        return BinarySearch(needle, sortedHaystack, 0, sortedHaystack.Length - 1);
    }
    static thing BinarySearch(int needle, thing[] sortedHaystack, int minimum, int maximum)
    {
        if (minimum > maximum)
            return null;
        var middle = (minimum + maximum) / 2;
        if (needle == sortedHaystack[middle].value)
            return sortedHaystack[middle];
        if (needle < sortedHaystack[middle].value)
            return BinarySearch(needle, sortedHaystack, minimum, middle - 1);
        return BinarySearch(needle, sortedHaystack, middle + 1, maximum);
    }

    class thing
    {
        public int value;
        public thing(int v)
        {
            value = v;
        }
    }
}
4

1 回答 1

3

（几乎和评论中提到的一样。）

我怀疑您主要是看到缓存未命中的影响。当集合很大时，您会遇到很多缓存未命中 - 特别是使用二分搜索时，它可能需要触及集合中的很多点才能找到元素。

在较小的尺寸下，我怀疑您也会看到缓存未命中，但这一次在您的targets列表中 - 以及 LINQ 本身的开销。LINQ 速度很快，但是当您所做的只是对中间的一个小集合执行一次搜索时，它仍然很重要。

我建议将您的循环重写为：

{
    // Use the same seed each time for consistency. Doesn't have to be 0.
    Random random = new Random(0);
    watch.Start();
    int found = 0;
    for (int i = 0; i < 1000 * 1000; i++)
    {
        if (BinarySearch(t, random.Next(int.MaxValue)) != null)
        {
            found++;
        }
    }
    watch.Stop();
    Console.WriteLine(string.Format
         "found {0} things out of {2} in {1} ms with binary search",
         found, watch.ElapsedMilliseconds, a.Length));
}

当然，你会遇到在循环中包含随机数生成的问题......你可能想看看使用一个比System.Random你能找到一个更快的随机数生成器。或者使用其他方式来确定要查找的元素。

哦，我个人会重写二进制搜索以使用迭代而不是递归，但这是另一回事。我不认为它会产生重大影响。

于 2013-10-15T06:19:05.230 回答