根据条件合并 IEnumerable 中的元素

Question

我一直在寻找一些快速有效的方法来合并数组中的项目。这是我的场景。集合按发件人排序。相邻元素不一定相差 1，即最后一个 To 和下一个 From 之间可能存在间隙，但它们永远不会重叠。

var list = new List<Range>();
list.Add(new Range() { From = 0, To = 1, Category = "AB" });
list.Add(new Range() { From = 2, To = 3, Category = "AB" });
list.Add(new Range() { From = 4, To = 5, Category = "AB" });
list.Add(new Range() { From = 6, To = 8, Category = "CD" });
list.Add(new Range() { From = 9, To = 11, Category = "AB" }); // 12 is missing, this is ok
list.Add(new Range() { From = 13, To = 15, Category = "AB" });

我希望以这样的方式合并上述集合，即前三个（这个数字可以变化，从至少 2 个元素到满足条件的多个元素）元素成为一个元素。无法合并具有不同类别的元素。

new Range() { From = 0, To = 5, Category = "AB" };

这样生成的集合总共有 4 个元素。

0 - 5    AB
6 - 8    CD
9 - 11   AB // no merging here, 12 is missing
13 - 15  AB

我有一个非常大的集合，包含超过 2.000.000 项，我希望尽可能高效地完成此操作。

Answer 1

这是另一个：

IEnumerable<Range> Merge(IEnumerable<Range> input)
{
    input = input.OrderBy(r => r.Category).ThenBy(r => r.From).ThenBy(r => r.To).ToArray();
    var ignored = new HashSet<Range>();
    foreach (Range r1 in input)
    {
        if (ignored.Contains(r1))
            continue;

        Range tmp = r1;
        foreach (Range r2 in input)
        {
            if (tmp == r2 || ignored.Contains(r2))
                continue;

            Range merged;
            if (TryMerge(tmp, r2, out merged))
            {
                tmp = merged;
                ignored.Add(r1);
                ignored.Add(r2);
            }
        }
        yield return tmp;
    }
}

bool TryMerge(Range r1, Range r2, out Range merged)
{
    merged = null;
    if (r1.Category != r2.Category)
        return false;
    if (r1.To + 1 < r2.From || r2.To + 1 < r1.From)
        return false;
    merged = new Range
    {
        From = Math.Min(r1.From, r2.From),
        To = Math.Max(r1.To, r2.To),
        Category = r1.Category
    };
    return true;
}

你可以直接使用它：

var mergedList = Merge(list);

但是如果你有很多项目，因为复杂度是 O(n²)，那将是非常低效的。但是，由于只能合并同一类别的项目，因此可以将它们按类别分组并合并每个组，然后将结果展平：

var mergedList = list.GroupBy(r => r.Category)
                    .Select(g => Merge(g))
                    .SelectMany(g => g);

Answer 2

假设列表已排序 - 并且 - 范围不重叠，正如您在问题中所述，这将在 O(n) 时间内运行：

var flattenedRanges = new List<Range>{new Range(list.First())};

foreach (var range in list.Skip(1))
{
    if (flattenedRanges.Last().To + 1 == range.From && flattenedRanges.Last().Category == range.Category)
        flattenedRanges.Last().To = range.To;
    else
        flattenedRanges.Add(new Range(range));
}

这是假设您有一个 Range 的复制构造函数

编辑： 这是一个就地算法：

    for (int i = 1; i < list.Count(); i++)
    {
        if (list[i].From == list[i - 1].To+1  && list[i-1].Category == list[i].Category)
        {
            list[i - 1].To = list[i].To;
            list.RemoveAt(i--);
        }
    }

编辑：

添加了分类检查，并修复了就地版本。

Answer 3

这是一个通用的、可重复使用的解决方案，而不是一个临时的、特定的解决方案。 （根据cmets更新）

IEnumerable<T> Merge<T>(this IEnumerable<T> coll, 
                      Func<T,T,bool> canBeMerged, Func<T,T,T>mergeItems)
{
    using(IEnumerator<T> iter = col.GetEnumerator())
    {
      if (iter.MoveNext())
      {
          T lhs = iter.Current;
          while(iter.MoveNext())
          {
              T rhs = iter.Current;
              if (canBeMerged(lhs, rhs)
                 lhs=mergeItems(lhs, rhs);
              else
              {
                 yield return lhs;
                 lhs= rhs;
              }
          }
          yield return lhs;
      }
    }
}

您必须提供方法来确定项目是否可以合并，并合并它们。 这些确实应该是 Range 类的一部分，所以它会像它们一样被调用：

list.Merge((l,r)=> l.IsFollowedBy(r), (l,r)=> l.CombineWith(r));

如果你没有这些方法，那么你将不得不这样称呼它：

list.Merge((l,r)=> l.Category==r.Category && l.To +1 == r.From,
           (l,r)=> new Range(){From = l.From, To=r.To, Category = l.Category});

Answer 4

好吧，从问题的陈述来看，我认为很明显，您无法避免遍历 200 万个项目的原始集合：

var output = new List<Range>();
var currentFrom = list[0].From;
var currentTo = list[0].To;
var currentCategory = list[0].Category;
for (int i = 1; i < list.Count; i++)
{
    var item = list[i];
    if (item.Category == currentCategory && item.From == currentTo + 1)
        currentTo = item.To;
    else
    {
        output.Add(new Range { From = currentFrom, To = currentTo,
            Category = currentCategory });
        currentFrom = item.From;
        currentTo = item.To;
        currentCategory = item.Category;
    }
}
output.Add(new Range { From = currentFrom, To = currentTo,
    Category = currentCategory });

我很想看看是否有更优化性能的解决方案。

编辑：我假设输入列表已排序。如果不是，我建议先对其进行排序，而不是尝试将其放入算法中。排序只需要 O(n log n)，但如果你试着把它弄进去，你很容易得到 O(n²)，这更糟。

list.Sort((a, b) => a.From < b.From ? -1 : a.From > b.From ? 1 : 0);

顺便说一句，我写这个解决方案是因为您要求一个性能优化的解决方案。为此，我没有把它做成泛型，没有使用委托，没有使用Linq扩展方法，使用原始类型的局部变量，尽量避免访问对象字段。