在 Dictionary<DateTime, double> 中查找最近的 DateTime 键

Question

我将 DateTime 的 Date 部分作为查找值，并希望在 Dictionary<DateTime, double> 类型的字典中检索匹配值。请注意，日期时间键仅存储为日期部分。

我的问题是可能没有与我的查找值匹配的键。然后我想做的是找到最近的 previous dateTime.Date 键和匹配值。

现在，我知道字典不是按键排序的。我可以使用 SortedDictionary 但出于特定原因更喜欢使用 Dictionary 或者切换到 List 集合（可以预先排序）。我的问题是，在这种情况下你会建议做什么：保留字典结构并减少我的查找值直到找到匹配的键会更有效吗？或者使用列表集合并使用Linq会更好吗？每个字典包含大约 5000 个键/值对。另外，请注意我寻找一个计算效率很高的解决方案，因为查找的频率非常高（可能数十万次（每次查找都保证与之前的任何值不同）

Answer 1

为什么要担心早产儿眼科

去做

只有那么如果它很慢，那么你就有问题了 用探查器测量它

然后理解开始于您尝试其他方法并分析它们。

答案是：如果您以任何方式进行操作并且没有性能问题，那么您只是节省了时间并设法做一些其他有用的事情来增加您一天的价值。

过早的优化不仅没有意义，您通常会完全错误地判断应该查看的位置。

Answer 2

由于您需要快速，我认为最好的办法是使用BinarySearch 的结果。这需要一个已排序的List<T>。

int result = myList.BinarySearch(targetDate);
if (result >= 0)
    return myList[result];
else
{
    int nextLarger = ~result;
    // return next smaller, or if that doesn't exist, the smallest one
    return myList[Math.Max(0, nextLarger - 1)];
}

应该可以创建一个结合Dictionary<TKey,TValue> 和排序的List<TKey> 的类，该类仍然像Dictionary<TKey,TValue> 一样序列化。序列化可能很简单（在 Json.NET 中），只需在您的类上添加 [JsonConverter(typeof(KeyValuePairConverter))]。

为了完整起见，以防其他人将来阅读此内容，如果速度不是很重要，您可以更简单地使用以下内容：

var result = myDict.Keys.Where(x => x < targetDate).Max();

Answer 3

我会使用自定义结构和集合来存储这些信息：

public struct DateValue
{
    public DateValue(DateTime date, double val)
        : this()
    {
        this.Date = date;
        this.Value = val;
    }
    public DateTime Date { get; set; }
}

这是一个集合的可能实现，它包含所有DateValues 并封装返回最近的逻辑。它使用List.BinarySearch 来查找它。如果它没有找到直接匹配，它使用BinarySearch 的逻辑来检测最近的是：

指定值在指定数组中的索引，如果值为 成立。如果未找到值且值小于一个或多个 数组中的元素，一个负数，它是按位补码 大于 value 的第一个元素的索引。如果值 未找到且值大于数组中的任何元素，a 负数，它是（的索引的按位补码 最后一个元素加 1)。

public class DateValueCollection : List<DateValue>, IComparer<DateValue>
{
    public DateValueCollection() { }

    public DateValueCollection(IEnumerable<DateValue> dateValues, bool isOrdered)
    {
        if (isOrdered)
            base.AddRange(dateValues);
        else
            base.AddRange(dateValues.OrderBy(dv => dv.Date));
    }

    public DateValue GetNearest(DateTime date)
    {
        if (base.Count == 0)
            return default(DateValue);

        DateValue dv = new DateValue(date, 0);
        int index = base.BinarySearch(dv, this);

        if (index >= 0)
        {
            return base[index];
        }
        // If not found, List.BinarySearch returns the complement of the index
        index = ~index;

        DateValue[] all;
        if(index >= base.Count - 1)
        {
            // proposed index is last, check previous and last
            all = new[] { base[base.Count - 1], base[base.Count - 2] };
        }
        else if(index == 0)
        {
            // proposed index is first, check first and second
            all = new[] { base[index], base[index + 1] };
        }
        else
        {
            // return nearest DateValue from previous and this
            var thisDV = base[index];
            var prevDV = base[index - 1];
            all = new[]{ thisDV, prevDV };
        }
        return all.OrderBy(x => (x.Date - date).Duration()).First();
    }

    public int Compare(DateValue x, DateValue y)
    {
        return x.Date.CompareTo(y.Date);
    }
}

快速测试：

var dateVals = new[] { 
    new DateValue(DateTime.Today.AddDays(10), 1), new DateValue(DateTime.Today, 3), new DateValue(DateTime.Today.AddDays(4), 7) 
};
var dvCollection = new DateValueCollection(dateVals, false);
DateValue nearest = dvCollection.GetNearest(DateTime.Today.AddDays(1));