检查一个列表是否包含其他列表中的所有项目

时间:2013-08-03 21:47:22

标签: c# linq list

如何确定列表A是否包含同一订单中列表B中的所有元素?

列表A可以包含列表B没有的其他元素,但必须按照列表B包含它们的顺序包含列表B的所有元素。


示例1 列表A ...结尾, 4,0, 6 ):< / p>

List A:    List B:
5          2
9          3
2          4
3
4
0
6

这应该返回 True


示例2 列表A ...结尾, 0,4 ,6 ):< / p>

List A:    List B:
5          2
9          3
2          4
3
0
4
6

这应该返回 False


我发现这个answer from JonSkeet to see if List A contains all elements from List B但是,这并不要求它们处于相同的顺序。

4 个答案:

答案 0 :(得分:4)

这会占用ListA的每个部分,并将其与ListBSequenceEqual进行比较:

bool containsSameSequence = ListA
    .Where((item, index) => index <= ListA.Count - ListB.Count)
    .Select((item, index) => ListA.Skip(index).Take(ListB.Count))
    .Any(part => part.SequenceEqual(ListB));

Demo

它在第一个匹配序列上返回true

答案 1 :(得分:3)

这是一个快速的方法:

var equal = listA.Count - listB.Count < 0 
    ? false 
    : Enumerable.Range(0, listA.Count - listB.Count).Any(i => 
      listA.Skip(i).Take(listB.Count).SequenceEqual(listB));

但是,我更喜欢使用这样的扩展方法:

public static bool ContainsSequence<T>(this IEnumerable<T> outer, 
                                       IEnumerable<T> inner)
{
    var innerCount = inner.Count();
    for(int i = 0; i < outer.Count() - innerCount; i++)
    {
        if(outer.Skip(i).Take(innerCount).SequenceEqual(inner))
            return true;
    }

    return false;
 }

你可以这样称呼:

var equals = listA.ContainsSequence(listB);

这是针对List<T>特定的相同扩展方法的高效版本:

public static bool ContainsSequence<T>(this List<T> outer, List<T> inner)
{
    var innerCount = inner.Count;

    for (int i = 0; i < outer.Count - innerCount; i++)
    {
        bool isMatch = true;
        for (int x = 0; x < innerCount; x++)
        {
            if (!outer[i + x].Equals(inner[x]))
            {
                isMatch = false;
                break;
            }
        }

        if (isMatch) return true;
    }

    return false;
}

答案 2 :(得分:1)

使用String.Join()将ListA元素连接在一起。然后再次使用它将List元素连接在一起。然后使用ConcatListA.IndexOf(ConcatListB)

答案 3 :(得分:0)

我认为我的版本效率更高。

public static class CollectionExtension
{
    public static bool SequenceContain<T>(this IEnumerable<T> target, IEnumerable<T> that)
    {
        var targetEnumerater = target.GetEnumerator();
        var thatEnumerater = that.GetEnumerator();
        var thatHasValue = thatEnumerater.MoveNext();
        var targetHasValue = targetEnumerater.MoveNext();
        var matchCount = 0;
        try
        {
            while (thatHasValue && targetHasValue)
            {
                if (!EqualityComparer<T>.Default.Equals(targetEnumerater.Current, thatEnumerater.Current))
                {
                    if (matchCount > 0)
                    {
                        thatEnumerater.Reset();
                        thatEnumerater.MoveNext();
                        matchCount = 0;
                    }
                    targetHasValue = targetEnumerater.MoveNext();
                    continue;
                }
                targetHasValue = targetEnumerater.MoveNext();
                thatHasValue = thatEnumerater.MoveNext();
                matchCount++;
            }
            return matchCount == that.Count();
        }
        finally
        {
            thatEnumerater.Dispose();
            targetEnumerater.Dispose();
        }

    }
}