如何合并一个被拆分为 2 个具有奇数和偶数索引的数组的数组？

Question

来自这个问题： How to split an array to 2 arrays with odd and even indices respectively?

我已经使用这种方法将一个数组拆分为 2 个分别具有奇数和偶数索引的数组：

int[] a = new int[] { 1, 3, 7, 8 };

int[] aEven = a.Where((x, i) => i % 2 == 0).ToArray();
int[] aOdd = a.Where((x, i) => i % 2 != 0).ToArray();

这会产生 2 个数组：

aEven : {1, 7}
aOdd  : {3, 8}

如何以优雅的方式将aEven/aOdd 合并回原来的a 数组？

注意：我不会更改 aEven/aOdd 数组，并且保证两个数组的长度相同。

我需要来自aEven/aOdd 输入的输出是：

{ 1, 3, 7, 8 };

Answer 1

一种方法是结合Enumerable.Zip 和Enumerable.Aggregate 以及一点技巧。请注意，这仍然在引擎盖下使用循环。

var aList = aEven.Zip(aOdd, (even, odd) => new {even, odd})
                 .Aggregate(new List<int>(aEven.Length + aOdd.Length),
                            (list, z) =>
                            {
                                list.Add(z.even);
                                list.Add(z.odd);
                                return list;
                            });
if (aEven.Length != aOdd.Length)
    aList.Add(aEven[aEven.Length-1]);

var aOutput = aList.ToArray();

for (var i = 0; i < aOutput.Length; ++i)
    Console.WriteLine($"aOutput[{i}] ==> {aOutput[i]} == {a[i]} <== a[{i}]");

这仅适用于您的场景但是（拆分然后通过奇数/偶数索引恢复数组，假设“子数组”的顺序被维护）。

结果数组将具有相同的大小（原始数组具有偶数项）或偶数数组将具有一个额外项（原始数组具有奇数项）。在后一种情况下，额外的项目将被Zip 丢弃，需要手动计算。这不适用于通过其他方式计算两个子数组的其他场景。

您也可以在没有中间列表的情况下使用预先分配的数组来执行此操作，但您必须跟踪 LINQ 调用之外的索引（我不太喜欢）：

var index = 0;
var aOutput = aEven.Zip(aOdd, (even, odd) => new {even, odd})
                   .Aggregate(new int[aEven.Length + aOdd.Length],
                             (arr, z) =>
                             {
                                 arr[index++] = z.even;
                                 arr[index++] = z.odd;
                                 return arr;
                             });
if (aEven.Length != aOdd.Length)
    aOutput[index] = aEven[aEven.Length-1];

另一种方法是使用Zip、SelectMany 和Concat 的组合（考虑最后一项）：

var aOutput = aEven.Zip(aOdd, (even, odd) => new[]{ even, odd })
    .SelectMany(z => z)
    .Concat(aEven.Length == aOdd.Length ? new int[0] : new []{ aEven[aEven.Length - 1] })
    .ToArray();

简单的 for 循环可能仍然是最简单的解决方案。

Answer 2

只需使用 for 循环代替。它不会创建所有这些中间元组数组，但具有相当的可读性并且需要相同数量的代码。

int[] Merge(int[] evenItems, int[] oddItems)
{
    var itemsCount = evenItems.Length + oddItems.Length;
    var result = new int[itemsCount];

    for (var i = 0; i < itemsCount; i++)
    {
        var sourceIndex = Math.DivRem(i, 2, out var remainder);
        var source = remainder == 0 ? evenItems : oddItems;
        result[i] = source[sourceIndex];
    }

    return result;
}

Answer 3

public static IEnumerable<T> MergeByZipAndRemainder<T>(T[] this firsts, T[] seconds)
{
  int maxLength = Math.Max(firsts.Length, seconds.Length);
  foreach(int i in Enumerable.Range(0, maxLength))
  {
     if (i < firsts.Length) { yield return firsts[i]; }
     if (i < seconds.Length) { yield return seconds[i]; }
  }
}

然后：

var result = evens.MergeByZipAndRemainder(odds).ToArray();

这种方法遇到了回答者的一些批评。

• 优雅。
• 它解决了合并长度可能非常不同的数组的一般情况。
• 它只枚举一次 O(N+M)。
• 它不分配需要垃圾回收的中间数组对象。
• 理论上应该更快，但我没有测量性能。

Answer 4

创建InterlockWith 扩展方法，是的，没有逃脱循环：

public static IEnumerable<T> InterlockWith<T>(this IEnumerable<T> seq1, IEnumerable<T> seq2)
    {
        Tuple<T[], int>[] metaSequences = new Tuple<T[], int>[2];
        metaSequences[0] = Tuple.Create(seq1.ToArray(), seq1.Count());
        metaSequences[1] = Tuple.Create(seq2.ToArray(), seq2.Count());
        var orderedMetas = metaSequences.OrderBy(x => x.Item2).ToArray();

        for (int i = 0; i < orderedMetas[0].Item2; i++)
        {
            yield return metaSequences[0].Item1[i];
            yield return metaSequences[1].Item1[i];
        }

        var remainingItems = orderedMetas[1].Item1.Skip(orderedMetas[0].Item2);
        foreach (var item in remainingItems)
        {
            yield return item;
        }
    }

你可以像这样调用它来获得你的结果集：

a = aEven.InterlockWith(aOdd).ToArray();

Answer 5

var merged = evens
  .Zip(odds, (even, odd) => new [] {even, odd})
  .SelectMany(pair => pair)
  .Concat(evens.Skip(odds.Length))
  .ToArray();

Answer 6

首先你可以使用 Concat 合并它们，然后如果你想对 reslt 进行排序，你可以使用 OrderBy ：

aEven.Concat(aOdd).OrderBy(b => b).ToArray();