使用 Linq 在 IEnumerable<T> 中查找序列

Question

使用 LINQ 在IEnumerable<T> 中查找序列的最有效方法是什么

我希望能够创建一个允许以下调用的扩展方法：

int startIndex = largeSequence.FindSequence(subSequence)

匹配必须相邻且有序。

Answer 1

您可以使用这个名为 Sequences 的库来执行此操作（免责声明：我是作者）。

它有一个 IndexOfSlice 方法，可以完全满足您的需求 - 它是 Knuth-Morris-Pratt algorithm 的 implementation。

int startIndex = largeSequence.AsSequence().IndexOfSlice(subSequence);

Answer 2

我知道这是一个老问题，但我需要这个确切的方法，我这样写：

public static int ContainsSubsequence<T>(this IEnumerable<T> elements, IEnumerable<T> subSequence) where T: IEquatable<T>
{
    return ContainsSubsequence(elements, 0, subSequence);
}

private static int ContainsSubsequence<T>(IEnumerable<T> elements, int index, IEnumerable<T> subSequence) where T: IEquatable<T>
{
    // Do we have any elements left?
    bool elementsLeft = elements.Any();

    // Do we have any of the sub-sequence left?
    bool sequenceLeft = subSequence.Any();

    // No elements but sub-sequence not fully matched
    if (!elementsLeft && sequenceLeft)
        return -1; // Nope, didn't match

    // No elements of sub-sequence, which means even if there are
    // more elements, we matched the sub-sequence fully
    if (!sequenceLeft)
        return index - subSequence.Count(); // Matched!

    // If we didn't reach a terminal condition,
    // check the first element of the sub-sequence against the first element
    if (subSequence.First().Equals(e.First()))
        // Yes, it matched - move onto the next. Consume (skip) one element in each
        return ContainsSubsequence(elements.Skip(1), index + 1 subSequence.Skip(1));
    else
        // No, it didn't match. Try the next element, without consuming an element
        // from the sub-sequence
        return ContainsSubsequence(elements.Skip(1), index + 1, subSequence);
}

更新为不仅在子序列匹配时返回，而是在原始序列中开始的位置。

这是 IEnumerable 上的扩展方法，完全惰性，提前终止，并且比当前投票的答案更加 linq-ified。但是请注意（正如@wai-ha-lee 指出的那样）它 是递归的，并创建了 lot 的枚举数。在适用的情况下使用它（性能/内存）。这对我的需求来说很好，但是 YMMV。

Answer 3

这是一个在序列中查找子序列的算法的实现。我将方法称为IndexOfSequence，因为它使意图更加明确，并且类似于现有的IndexOf 方法：

public static class ExtensionMethods
{
    public static int IndexOfSequence<T>(this IEnumerable<T> source, IEnumerable<T> sequence)
    {
        return source.IndexOfSequence(sequence, EqualityComparer<T>.Default);
    }

    public static int IndexOfSequence<T>(this IEnumerable<T> source, IEnumerable<T> sequence, IEqualityComparer<T> comparer)
    {
        var seq = sequence.ToArray();

        int p = 0; // current position in source sequence
        int i = 0; // current position in searched sequence
        var prospects = new List<int>(); // list of prospective matches
        foreach (var item in source)
        {
            // Remove bad prospective matches
            prospects.RemoveAll(k => !comparer.Equals(item, seq[p - k]));

            // Is it the start of a prospective match ?
            if (comparer.Equals(item, seq[0]))
            {
                prospects.Add(p);
            }

            // Does current character continues partial match ?
            if (comparer.Equals(item, seq[i]))
            {
                i++;
                // Do we have a complete match ?
                if (i == seq.Length)
                {
                    // Bingo !
                    return p - seq.Length + 1;
                }
            }
            else // Mismatch
            {
                // Do we have prospective matches to fall back to ?
                if (prospects.Count > 0)
                {
                    // Yes, use the first one
                    int k = prospects[0];
                    i = p - k + 1;
                }
                else
                {
                    // No, start from beginning of searched sequence
                    i = 0;
                }
            }
            p++;
        }
        // No match
        return -1;
    }
}

我没有完全测试它，所以它可能仍然包含错误。我只是对著名的极端案例进行了一些测试，以确保我没有落入明显的陷阱。到目前为止似乎工作正常......

我认为复杂度接近 O(n)，但我不是大 O 表示法的专家，所以我可能是错的......至少它只枚举源序列一次，而不会返回，所以它应该是相当有效的。

Answer 4

你说你希望能够使用的代码不是 LINQ，所以我不明白为什么需要用 LINQ 来实现它。

这与子字符串搜索本质上是相同的问题（实际上，顺序很重要的枚举是“字符串”的概括）。

由于计算机科学长期以来一直在频繁考虑这个问题，所以你要站在巨人的肩膀上。

一些合理的起点是：

http://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm

http://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string_search_algorithm

http://en.wikipedia.org/wiki/Rabin-karp

即使只是维基百科文章中的伪代码，也足以轻松移植到 C#。查看不同情况下的性能描述，并确定您的代码最有可能遇到哪些情况。

Answer 5

更新： 鉴于问题的澄清，我下面的回答并不适用。出于历史目的而保留它。

您可能想要使用 mySequence.Where()。然后关键是优化谓词以在您的环境中正常工作。根据您的要求和典型的使用模式，这可能会有很大差异。

很可能适用于小型集合的方法不适用于更大的集合，具体取决于 T 的类型。

当然，如果 90% 的使用是针对小型集合，那么针对异常值大型集合进行优化似乎有点 YAGNI。