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

Question

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

    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 几乎相同，除了它使用自定义对象比较器。

        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];
        }

问题

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

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

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

            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 方法执行缓慢，没有别的。所以必须有一些内部进程会减慢 longs 的速度。

编辑：听从建议后，我使用benchmarkdotnet 实施了适当的基准测试，结果如下

Method	N	Mean	Error	StdDev	Gen0	Allocated
BinaryFindClosest	10000	28.31 ns	0.409 ns	0.362 ns	-	-
BinaryFindClosest2	10000	75.85 ns	0.865 ns	0.722 ns	0.0014	24 B
FindClosest	10000	3,363,223.68 ns	63,300.072 ns	52,858.427 ns	-	2 B

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

        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)的定义在哪里？为什么它同时接收类实例和longs 的列表？为什么不返回在长列表上应用二分搜索的索引，并用它来索引原始蜡烛列表？ （如果您使用 select 创建 longs 的列表，列表中的 1:1 关系将被保留）

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

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

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

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).
}