排序字典自定义键查找以提高效率

Question

最近，我了解到Sorted Dictionary 类实现了对键的二进制搜索，我想利用它来发挥我的优势。我正在制作一个piecewise 线性函数类，它表示一系列间隔上的线条集合。

我这样定义了一个Interval 类：

public class Interval : ICloneable, IComparable, IComparable<Interval>
{
    public Interval()
    {

    }
    public Interval(double start, double end)
    {
        Start = start;
        End = end;
    }

    // Properties
    public double Start { get; set; } = double.NaN;
    public double End { get; set; } = double.NaN;
    public double Span => End - Start;

    // Methods
    public object Clone() => MemberwiseClone();

    public int CompareTo(object obj)
    {
        return Start.CompareTo(obj);
    }

    public int CompareTo([AllowNull] Interval other)
    {
        if (Start < other.Start)
        {
            return -1;
        }
        else if (Start > other.Start)
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }

    public bool Contains(double x) => Start <= x && x <= End;
    public override string ToString() => $"[{Start}, {End}]";
}

而有问题的SortedDictionary 在分段函数类中的工作方式如下：

public class PiecewiseLinearFunction : ICloneable
{
    ...
    // The dictionary
    public SortedDictionary<Interval, Line2D> Functions { get; set; } = new SortedDictionary<Interval, Line2D>(); // Where Line2D is just a class that contains a function definition for a line

    // Methods
    public Interval FindInterval(double x)
        => Functions.Keys.Where(interval => interval.Contains(x)).FirstOrDefault();
    public double Solve(double x)
    {
        var interval = FindInterval(x);
        if (interval != null && Functions.ContainsKey(interval))
        {
            return Functions[interval].Solve(x);
        }
        else
        {
            return double.NaN;
        }
    }
}

如您所见，PiecewiseLinearFunction.FindInterval(double x) 方法线性搜索字典的键，以便找到包含（或不包含）x 的区间，可用于二进制查找，但这显然完全违背了进行二进制查找的目的。

我想知道是否可以以某种方式让字典查找 double x 值，并在检查 Interval.Contains(double x) 是 true 或 false 的同时对区间进行二进制搜索以确定是否存在有效区间（key）和对应的行，可用于获取x处的函数值。

换句话说，有没有办法使用谓词进行搜索，例如FindInterval(double x) => Functions.Keys.FindBinary(i => i.Contains(x))。

Answer 1

因此，如果间隔不重叠，则实际上不需要自定义二进制搜索。

首先，如果我们将Interval 与double 相媲美会有所帮助：

public class Interval: IComparable<double>
{
    public double Start { get; set; }
    public double End { get; set; }

    public bool Contains(double x) => x >= Start && x <= End;
    public int CompareTo(double other)
    {
        if (Contains(other))
            return 0;
        return other < Start ? 1 : -1;
    }
}

现在我们创建了一个List 扩展，这样我们就可以对其他类型进行二分搜索，而不仅仅是列表的类型：

public static class ListExtensions
{
    public static int BinarySearch<T, TU>(this List<T> sortedSource, TU val) where T : IComparable<TU>
    {
        return sortedSource.BinarySearch(default(T), Comparer<T>.Create((item, _) => item.CompareTo(val)));
    }
}

现在我们可以像这样测试它：

var list = new List<Interval>
{
    new Interval
    {
        Start = 0,
        End = 4
    },
    new Interval
    {
        Start = 6,
        End = 7
    },
    new Interval
    {
        Start = 10,
        End = 12
    }
};

var index = list.BinarySearch(6.0d); //index = 1
var interval = index < 0 ? null : list[index]; //interval = [6, 7]

index = list.BinarySearch(9.0d); //index = -3
interval = index < 0 ? null : list[index]; //interval = null