使用LINQ快速比较数组及判断数组是否为有序子序列的方法

嘿，这两个问题都是日常用LINQ时很常见的需求，我来给你拆解下具体的实现方案！

首先得明确你的比较需求：是要判断两个数组的元素顺序和值完全一致，还是只需要元素集合相同（忽略顺序）？不同需求对应不同的LINQ实现：

• 顺序和值完全一致：用LINQ自带的SequenceEqual方法就够了，这是最直接高效的方式，它会逐个比对两个序列的元素，一旦发现不匹配就立即返回结果，不用遍历完整个数组。
  示例代码：

  int[] arr1 = { 1, 2, 3, 4 };
  int[] arr2 = { 1, 2, 3, 4 };
  bool areEqual = arr1.SequenceEqual(arr2); // 返回true
  
  int[] arr3 = { 1, 3, 2, 4 };
  bool areNotEqual = arr1.SequenceEqual(arr3); // 返回false
  

  如果是自定义引用类型的数组，记得要么给类型重写Equals和GetHashCode，要么用SequenceEqual的重载传入自定义的IEqualityComparer<T>来指定比对规则。

• 忽略顺序，仅判断元素集合相同：可以先给两个数组排序，再用SequenceEqual比对：

  int[] arrA = { 3, 1, 2 };
  int[] arrB = { 1, 2, 3 };
  bool setsEqual = arrA.OrderBy(x => x).SequenceEqual(arrB.OrderBy(x => x)); // 返回true
  

必须可以！有序子序列的核心要求是：子数组的元素必须按顺序出现在主数组中，但不需要连续。比如主数组[1,2,3,4,5]，子数组[1,3,5]是符合要求的，而[3,1,5]就不行。

这里给你两种LINQ实现方式，都符合你接受嵌套查询的要求：

方式一：高效遍历版（推荐） #

利用All结合Array.IndexOf来跟踪当前匹配位置，找到一个元素后就从下一个位置继续查找，效率很高：

bool IsOrderedSubsequence<T>(T[] sub, T[] main) where T : IEquatable<T>
{
    if (sub.Length == 0) return true; // 空数组默认是任何数组的子序列
    int currentPos = -1;
    return sub.All(item => 
    {
        currentPos = Array.IndexOf(main, item, currentPos + 1);
        return currentPos != -1;
    });
}

方式二：纯LINQ嵌套查询版 #

用Select、Any和Zip组合实现，完全基于LINQ的查询语法：

bool IsOrderedSubsequence<T>(T[] sub, T[] main) where T : IEquatable<T>
{
    if (sub.Length == 0) return true;
    return main.Select((_, idx) => idx)
               .Any(startIdx => 
                   sub.Zip(main.Skip(startIdx), (subItem, mainItem) => subItem.Equals(mainItem))
                      .All(isMatch => isMatch) && 
                   sub.Length <= main.Length - startIdx);
}

测试示例：

int[] mainArr = { 2, 4, 6, 8, 10 };
int[] validSub = { 4, 8 };
int[] invalidSub = { 8, 4 };

Console.WriteLine(IsOrderedSubsequence(validSub, mainArr)); // 输出True
Console.WriteLine(IsOrderedSubsequence(invalidSub, mainArr)); // 输出False

如果是引用类型，只需要把Equals替换成你自定义的相等判断逻辑就行，比如比对对象的ID属性。

内容的提问来源于stack exchange，提问作者H3ll0