C# 检查数组是否包含与其他数组完全相同的序列

我有一个问题，我需要检查某个数组是否是较大数组的一部分，这会很容易，但我需要检查较大数组是否包含完全相同的序列。比如说

int[] greaterArray = {8, 3, 4, 5, 9, 12, 6 ... n - elements}
int[] lesserArray = {3, 4, 5}

现在我需要知道小数组是否是这个数组的一部分，但序列相同，所以它包含3，4，5个相邻的大数组

我试过：

var exists = greaterArray.Intersect(lesserArray).Any();

---

但若较小数组中的任何元素存在于较大数组中，而不是确切的序列中，它会返回信息。有什么想法吗？

使用以下代码：

public bool ArraysEqual<T>(T[] a1, T[] a2)
{
    if (ReferenceEquals(a1,a2))
        return true;

    if (a1 == null || a2 == null)
        return false;

    if (a1.Length != a2.Length)
        return false;

    EqualityComparer<T> comparer = EqualityComparer<T>.Default;
    for (int i = 0; i < a1.Length; i++)
    {
        if (!comparer.Equals(a1[i], a2[i])) return false;
    }
    return true;
}

int[]greaterArray={8,3,4,5,9,12,6}；
int[]lesserray={3,4,5}；
bool sequenceFound=false；
对于（int i=0；i更为通用，且不使用LINQ）：

int[] greaterArray = {8, 2, 4, 5, 9, 12, 3, 4, 5};
int[] lesserArray = {3, 4, 5};
for (int i = 0; i <= greaterArray.Length - lesserArray.Length; i++)
            {
                var sub = greaterArray.SubArray(i, lesserArray.Length);
                if (Enumerable.SequenceEqual(sub, lesserArray))
                {
                    Console.WriteLine("Equals!");
                }
            }

int[]greaterArray={8,2,4,5,9,12,3,4,5}；
int[]lesserray={3,4,5}；
对于（inti=0；i这应该可以完成你的工作

int[] grtarr = { 8, 3, 4, 5, 9, 12, 6 };
int[] lsarr = { 3, 4, 5 };

List<int> lstGrtArr = grtarr.ToList();
List<int> lstLsrArr = lsarr.ToList();

bool sequenceMatch = false;

for (int i = 0; i < grtarr.Count(); i++)
{
    if (lstGrtArr.Where(x => lstGrtArr.IndexOf(x) >= i).Take(lstLsrArr.Count()).SequenceEqual(lstLsrArr))
    {
        sequenceMatch = true;
        break;
    }
}

if(sequenceMatch)
{
    //Do Something
}

int[]grtarr={8,3,4,5,9,12,6}；
int[]lsarr={3,4,5}；
List lstgrtar=grtarr.ToList（）；
List lstrarr=lsarr.ToList（）；
bool sequenceMatch=false；
对于（int i=0；ilstgrtar.IndexOf（x）>=i）.Take（lstlsrar.Count（））.SequenceEqual（lstlsrar））
{
sequenceMatch=true；
打破
}
}
if（sequenceMatch）
{
//做点什么
}
静态bool-isPrefix（int[]源，int-start\u-pos，int[]前缀）
{
bool result=start_pos+prefix.Length@JaydipJ该答案不涉及子集。这只是根据您在问题标题检查数组是否包含与其他数组完全相同的序列而不是我的问题标题中所述的内容。不过，事实仍然是，它没有回答问题。绝对不是@JaydipJ。他问的是子序列而不是问题标题相同的阵列您的两种解决方案的性能有何不同？它不像您的
ArraysEqual
包含一些加速魔法（但不是my-1）。这并不能回答问题。OP询问
lesserray
是否是
greaterray
的子集，且元素的顺序相同。您可能需要将
Take（3）
中的硬编码3替换为
lesserray.Length
。
int[] greaterArray = {8, 2, 4, 5, 9, 12, 3, 4, 5};
int[] lesserArray = {3, 4, 5};
for (int i = 0; i <= greaterArray.Length - lesserArray.Length; i++)
            {
                var sub = greaterArray.SubArray(i, lesserArray.Length);
                if (Enumerable.SequenceEqual(sub, lesserArray))
                {
                    Console.WriteLine("Equals!");
                }
            }

public static T[] SubArray<T>(this T[] data, int index, int length)
        {
            T[] result = new T[length];
            Array.Copy(data, index, result, 0, length);
            return result;
        }

int[] grtarr = { 8, 3, 4, 5, 9, 12, 6 };
int[] lsarr = { 3, 4, 5 };

List<int> lstGrtArr = grtarr.ToList();
List<int> lstLsrArr = lsarr.ToList();

bool sequenceMatch = false;

for (int i = 0; i < grtarr.Count(); i++)
{
    if (lstGrtArr.Where(x => lstGrtArr.IndexOf(x) >= i).Take(lstLsrArr.Count()).SequenceEqual(lstLsrArr))
    {
        sequenceMatch = true;
        break;
    }
}

if(sequenceMatch)
{
    //Do Something
}

    static bool isPrefix(int[] source, int start_pos, int[] prefix)
    {
        bool result = start_pos + prefix.Length <= source.Length;
        for (int i = 0; result && i < prefix.Length; ++i, ++start_pos)
            result = source[start_pos] == prefix[i];
        return result;
    }
    static bool Contains(int[] source, int[] prefix)
    {
        bool result = false;
        for (int i = 0; !result && i < source.Length; ++i)
            result = source[i] == prefix[0] ? isPrefix(source, i, prefix) : false;
        return result;
    }