有比较器的二分搜索比没有比较器快

Question

我有一个包含大约 200 万条记录的数据。 我试图找到最接近给定时间范围的单个数据。 数据列表是有序的，数据由以下class表示：

    public class DataPoint
    {
        public long OpenTimeTs;
    }

我已经实施了 3 种方法来完成相同的工作并产生相同的结果。 我对为什么其中一种方法执行得更快有一些疑问

方法一

在long列表中使用二进制搜索

        private DataPoint BinaryFindClosest(List<DataPoint> candles, List<long> times, long dateToFindMs)
        {
            int index = times.BinarySearch(dateToFindMs);

            if (index >= 0)
                return candles[index];

            // If not found, List.BinarySearch returns the complement 
            // of the index where the element should have been.
            index = ~index;

            // This date search for is larger than any
            if (index == times.Count)
                return candles[index - 1];

            // The date searched is smaller than any in the list.
            if (index == 0)
                return candles[0];

            if (Math.Abs(dateToFindMs - times[index - 1]) < Math.Abs(dateToFindMs - times[index]))
                return candles[index - 1];
            else
                return candles[index];
        }

方法二

与方法 1 几乎相同，除了它使用自定义 object 比较器。

        private DataPoint BinaryFindClosest2(List<DataPoint> candles, DataPoint toFind)
        {
            var comparer = Comparer<DataPoint>.Create((x, y) => x.OpenTimeTs > y.OpenTimeTs ? 1 : x.OpenTimeTs < y.OpenTimeTs ? -1 : 0);

            int index = candles.BinarySearch(toFind, comparer);

            if (index >= 0)
                return candles[index];

            // If not found, List.BinarySearch returns the complement 
            // of the index where the element should have been.
            index = ~index;

            // This date search for is larger than any
            if (index == candles.Count)
                return candles[index - 1];

            // The date searched is smaller than any in the list.
            if (index == 0)
                return candles[0];

            if (Math.Abs(toFind.OpenTimeTs - candles[index - 1].OpenTimeTs) < Math.Abs(toFind.OpenTimeTs - candles[index].OpenTimeTs))
                return candles[index - 1];
            else
                return candles[index];
        }

方法三

最后，这是我在其他主题中发现 stackoverflow 上的BinarySearch方法之前一直使用的方法。

        private DataPoint FindClosest(List<DataPoint> candles, DataPoint toFind)
        {
            long timeToFind = toFind.OpenTimeTs;

            int smallestDistanceIdx = -1;
            long smallestDistance = long.MaxValue;

            for (int i = 0; i < candles.Count(); i++)
            {
                var candle = candles[i];
                var distance = Math.Abs(candle.OpenTimeTs - timeToFind);
                if (distance <= smallestDistance)
                {
                    smallestDistance = distance;
                    smallestDistanceIdx = i;
                }
                else
                {
                    break;
                }
            }

            return candles[smallestDistanceIdx];
        }

问题

现在问题来了。 运行一些基准测试后，我注意到第二种方法（使用自定义比较器）是其他方法中最快的。

我想知道为什么使用自定义比较器的方法比在long列表中进行二进制搜索的方法执行得更快。

我正在使用以下代码来测试这些方法：

            var candles = AppState.GetLoadSymbolData();
            var times = candles.Select(s => s.OpenTimeTs).ToList();

            var dateToFindMs = candles[candles.Count / 2].OpenTimeTs;
            var candleToFind = new DataPoint() { OpenTimeTs = dateToFindMs };

            var numberOfFinds = 100_000;

            var sw = Stopwatch.StartNew();
            for (int i = 0; i < numberOfFinds; i++)
            {
                var foundCandle = BinaryFindClosest(candles, times, dateToFindMs);
            }
            sw.Stop();
            var elapsed1 = sw.ElapsedMilliseconds;

            sw.Restart();
            for (int i = 0; i < numberOfFinds; i++)
            {
                var foundCandle = BinaryFindClosest2(candles, candleToFind);
            }
            sw.Stop();
            var elapsed2 = sw.ElapsedMilliseconds;
            
            sw.Restart();
            for (int i = 0; i < numberOfFinds; i++)
            {
                var foundCandle = FindClosest(candles, candleToFind);
            }
            sw.Stop();
            var elapsed3 = sw.ElapsedMilliseconds;

            Console.WriteLine($"Elapsed 1: {elapsed1} ms");
            Console.WriteLine($"Elapsed 2: {elapsed2} ms");
            Console.WriteLine($"Elapsed 3: {elapsed3} ms");

在发布模式下，结果如下：

• 经过 1：19 毫秒
• 经过 2：1 毫秒
• 经过 3：60678 毫秒

从逻辑上讲，我会假设比较多头列表应该更快，但事实并非如此。 我尝试分析代码，但它只指向BinarySearch方法执行缓慢，没有别的。所以必须有一些内部进程会减慢long s 的速度。

编辑：遵循建议后，我使用benchmarkdo.net实施了适当的基准测试，结果如下

方法	否	意思	错误	标准偏差	Gen0	已分配
BinaryFindClosest	10000	28.31 纳秒	0.409纳秒	0.362 纳秒	-	-
BinaryFindClosest2	10000	75.85 纳秒	0.865 纳秒	0.722 纳秒	0.0014	24乙
查找最近的	10000	3,363,223.68 纳秒	63,300.072 纳秒	52,858.427 纳秒	-	2乙

看起来执行方法的顺序确实弄乱了我的初始结果。 现在看起来第一种方法工作得更快（而且应该如此）。 最慢的当然是我自己实现了。 我稍微调整了一下，但它仍然是最慢的方法：

        public static DataPoint FindClosest(List<DataPoint> candles, List<long> times, DataPoint toFind)
        {
            long timeToFind = toFind.OpenTimeTs;

            int smallestDistanceIdx = -1;
            long smallestDistance = long.MaxValue;

            var count = candles.Count();
            for (int i = 0; i < count; i++)
            {
                var diff = times[i] - timeToFind;
                var distance = diff < 0 ? -diff : diff;
                if (distance < smallestDistance)
                {
                    smallestDistance = distance;
                    smallestDistanceIdx = i;
                }
                else
                {
                    break;
                }
            }

            return candles[smallestDistanceIdx];
        }

长话短说——使用合适的基准测试工具。

Answer 1

请查看方法 1 和 2 生成的 IL。 这可能是一个无效的测试。 它们应该是几乎相同的机器码。

第一：我看不出你在哪里保证订购。 但假设它以某种方式在那里。 二分搜索将在几乎 20 到 25 步内找到最隐藏的数字 (log2(2.000.000))。 这个测试闻起来很奇怪。

第二： BinaryFindClosestCandle(candles, times, dateToFindMs)的定义在哪里？ 为什么它同时收到 class 实例和long列表？ 为什么不返回在长列表上应用二分搜索的索引，并用它来索引原始蜡烛列表？ （如果您使用 select 创建long列表，列表中的 1:1 关系将保留）

第三：您使用的数据是 class，因此所有元素都在堆上。 您在 method2 中装箱了一个包含 200 万个长数字的数组。 这几乎是一种犯罪。 从堆中引用数据将比比较本身花费更多。 我仍然认为列表没有排序。

创建一个交换列表以应用 seach 算法，就像您对times所做的那样，但是将其转换为带有.ToArray()的数组并将其放在堆栈上。 我认为市场上没有比long valueTypes 的默认比较器更好的了。

编辑解决方案提示：根据您在一次查找最小值之前执行的插入次数，我将 go 用于以下内容：

if (insertions/lookups > 300.000)
{
    a. store the index of the minimum (and the minimum value) apart in a dedicated field, I would store also a flag for IsUpdated to get false at the first deletion from the list.
    b. spawn a parallel thread to refresh that index and the minumum value at every now an then (depending on how often you do the lookups) if the IsUpdated is false, or lazily when you start a lookup with a IsUpdated = false.
}
else
{
    use a dictionary with the long as a key ( I suppose that two entities with the same long value are likely to be considered equal).
}