对象的重叠列表

如果你关心的只是是否存在重叠，而不是哪些时间表重叠，那么你应该能够在O(n log n(中做到这一点。关键是按照它们的StartTime和EndTime(O(n-logn(部分(对时间表进行排序。然后，您可以枚举结果，并将每个计划的StartTime与上一个计划的EndTime进行比较。如果StartTime早于EndTime，则您有重叠的时间表。然而，如果没有第三方的帮助，我不认为这可以在一个查询中完成。我自己也是Ix-Main的粉丝。以下解决方案使用Ix-Main中的Buffer函数：

bool hasOverlap =
    list
    .OrderBy(x => x.StartTime)
    .ThenBy(x => x.EndTime)
    .Buffer(2, 1)
    .Where(x => x.Count == 2)
    .Where(x => x[1].StartTime < x[0].EndTime)
    .Any();

如果你不想使用第三方库，那么你可以对以下内容做同样的事情：

Schedule first = null;
bool hasOverlap = false;
using(var enumerator = list.OrderBy(x => x.StartTime).ThenBy(x => x.EndTime).GetEnumerator())
{
    enumerator.MoveNext();
    first = enumerator.Current;
    while(enumerator.MoveNext())
    {
        if(enumerator.Current.StartTime < first.EndTime)
        {
            hasOverlap = true;
            break;
        }
    }
}

假设性能不是问题(否则考虑重叠的算法(：

var pairs = from f in list 
            from s in list
            where (f.EndTime < s.StartTime) && (f.StartTime < s.EndTime) && (f != s)
            select new {First = f, Second = s };

基本上，我们正在检查所有可能的配对是否重叠。

或者，不使用查询语法：

var overlaps = list.SelectMany(l => list, (f, s) => new {f,s})
    .Where(x => (x.f.EndTime < x.s.StartTime) && 
               (x.f.StartTime < x.s.EndTime) && (x.f != x.s));

这是一种不同的方法，我不确定整件事的性能，但我们的想法是在BitArray中压平由您的时间表定义的范围，该BitArray会发出信号，表明前一个时间表是否已经使用了特定的分钟。

从技术上讲，它也不是一个"一行"的答案，尽管从调用代码的角度来看，它只是一行

所以假设已经定义了一个类ScheduleList

public class ScheduleList : List<Schedule>
{
    private BitArray ba = new BitArray(1440);
    // Define own Add method to Add a Schedule to the list
    // Or override the predefined one....
    public Schedule Add(int sh, int sm, int eh, int em)
    {
        Schedule s = new Schedule();
        s.StartTime = new DateTime(1, 1, 1, sh, sm, 0);
        s.EndTime = new DateTime(1, 1, 1, eh, em, 0);
        // Of course, having full control on the Add phase, you
        // could easily enforce your policy at this point. 
        // You could not accept a new schedule if the time slot is busy
        // but we could ignore it at this point
        this.Add(s);
        return s;
    }
    public bool IsTimeSlotBusy(Schedule s)
    {
        int sidx = Convert.ToInt32(TimeSpan.FromMinutes((s.StartTime.Hour * 60) + s.StartTime.Minute).TotalMinutes);
        int eidx = Convert.ToInt32(TimeSpan.FromMinutes((s.EndTime.Hour * 60) + s.EndTime.Minute).TotalMinutes);
        for (int x = sidx; x <= eidx; x++)
        {
            if (ba.Get(x)) return true;
            ba.Set(x, true);
        }
        return false;
    }
}

现在你可以写这样的

ScheduleList schedules = new ScheduleList();
schedules.Add(12, 0, 12, 30);
schedules.Add(15, 10, 15, 30);
schedules.Add(12, 0, 23, 59);
schedules.Add(14, 0, 23, 59);
// The fake 'one liner'
bool overlap = schedules.Any(s => schedules.IsTimeSlotBusy(s));
Console.WriteLine(overlap);

等着数学家们告诉我为什么这是最糟糕的。(并非讽刺，我真的想知道从数学角度来看这是否糟糕(