关于如何检查该列表是否是另一个列表的子集的任何想法？
具体来说，我有
List<double> t1 = new List<double> { 1, 3, 5 };
List<double> t2 = new List<double> { 1, 5 };
如何使用 LINQ 检查 t2 是否是 t1 的子集？
Ngu Soon Hui
问问题
54943 次
10 回答
273
bool isSubset = !t2.Except(t1).Any();
于 2008-12-02T04:12:33.647 回答
65
如果使用集合，请使用 HashSet 而不是 List。然后你可以简单地使用IsSubsetOf()
HashSet<double> t1 = new HashSet<double>{1,3,5};
HashSet<double> t2 = new HashSet<double>{1,5};
bool isSubset = t2.IsSubsetOf(t1);
抱歉，它不使用 LINQ。:-(
如果您需要使用列表，那么@Jared 的解决方案适用于您需要删除任何存在的重复元素的警告。
于 2008-12-02T03:57:54.377 回答
14
这是一个比此处发布的其他解决方案更有效的解决方案，尤其是顶级解决方案：
bool isSubset = t2.All(elem => t1.Contains(elem));
如果您可以在 t2 中找到一个不在 t1 中的元素，那么您就知道 t2 不是 t1 的子集。与使用 .Except 或 .Intersect 的解决方案不同，这种方法的优点是它全部就地完成，无需分配额外的空间。此外，该解决方案能够在找到违反子集条件的单个元素时立即中断，而其他元素继续搜索。以下是解决方案的最佳长形式，在我的测试中，它仅比上述速记解决方案快一点。
bool isSubset = true;
foreach (var element in t2) {
if (!t1.Contains(element)) {
isSubset = false;
break;
}
}
我对所有解决方案进行了一些基本的性能分析，结果非常好。这两个解决方案比 .Except() 和 .Intersect() 解决方案快大约 100 倍，并且不使用额外的内存。
于 2014-11-02T07:44:43.380 回答
13
如果您正在进行单元测试，您还可以使用CollectionAssert.IsSubsetOf方法：
CollectionAssert.IsSubsetOf(subset, superset);
在上述情况下，这意味着：
CollectionAssert.IsSubsetOf(t2, t1);
于 2014-08-27T11:40:02.533 回答
6
@Cameron 作为扩展方法的解决方案：
public static bool IsSubsetOf<T>(this IEnumerable<T> a, IEnumerable<T> b)
{
return !a.Except(b).Any();
}
用法：
bool isSubset = t2.IsSubsetOf(t1);
（这与@Michael 博客上发布的类似，但不完全相同）
于 2012-02-24T18:02:10.170 回答
4
我花了一些时间使用 BenchmarkDotNet 对这个答案中的 3 个工作解决方案进行基准测试。
!t2.Except(t1).Any()称为 except().Any()t2.IsSubsetOf(t1)称为哈希集t2.All(elem => t1.Contains(elem))称为全部（=>包含）
我改变了 3 个参数：
- 超集数
- 子集长度
- 项目的可变性
所有超集都是随机长度并包含 range 中的项目[0; Variability)。子集具有固定长度并包含范围内的项目[0; Variability)。
赢家是 All(=>Contains) 方法 - 它有时比使用 HashSets 快 30 倍，比 except().Any() 快 50 倍。
代码可以在github上找到
更新
正如@Gert Arnold 在评论中提到的，我的基准测试中有一个错误。ToHashSet()我在每次迭代中调用。因此，我还构建了一组预构建的哈希集，并添加了一个名为prebuilt HashSet. 它不是绝对的赢家，有时它会失去All(=>Contains)算法。在我看来，重点在于超集的可变性（和重复）。当值的可变性很低时 - 哈希集获胜，因为它将它从数据中删除。
决赛桌在这里：
| Method | SupersetsInIteration | SubsetLength | Variability | Mean | Error | StdDev | Median |
|------------------- |--------------------- |------------- |------------ |--------------:|-------------:|-------------:|--------------:|
| Except().Any() | 1000 | 10 | 100 | 1,485.89 μs | 7.363 μs | 6.887 μs | 1,488.36 μs |
| ToHashSet() | 1000 | 10 | 100 | 1,015.59 μs | 5.099 μs | 4.770 μs | 1,015.43 μs |
| prebuilt HashSet | 1000 | 10 | 100 | 38.76 μs | 0.065 μs | 0.054 μs | 38.78 μs |
| All(=>Contains) | 1000 | 10 | 100 | 105.46 μs | 0.320 μs | 0.267 μs | 105.38 μs |
| Except().Any() | 1000 | 10 | 10000 | 1,912.17 μs | 38.180 μs | 87.725 μs | 1,890.72 μs |
| ToHashSet() | 1000 | 10 | 10000 | 1,038.70 μs | 20.028 μs | 40.459 μs | 1,019.35 μs |
| prebuilt HashSet | 1000 | 10 | 10000 | 28.22 μs | 0.165 μs | 0.155 μs | 28.24 μs |
| All(=>Contains) | 1000 | 10 | 10000 | 81.47 μs | 0.117 μs | 0.109 μs | 81.45 μs |
| Except().Any() | 1000 | 50 | 100 | 4,888.22 μs | 81.268 μs | 76.019 μs | 4,854.42 μs |
| ToHashSet() | 1000 | 50 | 100 | 4,323.23 μs | 21.424 μs | 18.992 μs | 4,315.16 μs |
| prebuilt HashSet | 1000 | 50 | 100 | 186.53 μs | 1.257 μs | 1.176 μs | 186.35 μs |
| All(=>Contains) | 1000 | 50 | 100 | 1,173.37 μs | 2.667 μs | 2.227 μs | 1,173.08 μs |
| Except().Any() | 1000 | 50 | 10000 | 7,148.22 μs | 20.545 μs | 19.218 μs | 7,138.22 μs |
| ToHashSet() | 1000 | 50 | 10000 | 4,576.69 μs | 20.955 μs | 17.499 μs | 4,574.34 μs |
| prebuilt HashSet | 1000 | 50 | 10000 | 33.87 μs | 0.160 μs | 0.142 μs | 33.85 μs |
| All(=>Contains) | 1000 | 50 | 10000 | 131.34 μs | 0.569 μs | 0.475 μs | 131.24 μs |
| Except().Any() | 10000 | 10 | 100 | 14,798.42 μs | 120.423 μs | 112.643 μs | 14,775.43 μs |
| ToHashSet() | 10000 | 10 | 100 | 10,263.52 μs | 64.082 μs | 59.942 μs | 10,265.58 μs |
| prebuilt HashSet | 10000 | 10 | 100 | 1,241.19 μs | 4.248 μs | 3.973 μs | 1,241.75 μs |
| All(=>Contains) | 10000 | 10 | 100 | 1,058.41 μs | 6.766 μs | 6.329 μs | 1,059.22 μs |
| Except().Any() | 10000 | 10 | 10000 | 16,318.65 μs | 97.878 μs | 91.555 μs | 16,310.02 μs |
| ToHashSet() | 10000 | 10 | 10000 | 10,393.23 μs | 68.236 μs | 63.828 μs | 10,386.27 μs |
| prebuilt HashSet | 10000 | 10 | 10000 | 1,087.21 μs | 2.812 μs | 2.631 μs | 1,085.89 μs |
| All(=>Contains) | 10000 | 10 | 10000 | 847.88 μs | 1.536 μs | 1.436 μs | 847.34 μs |
| Except().Any() | 10000 | 50 | 100 | 48,257.76 μs | 232.573 μs | 181.578 μs | 48,236.31 μs |
| ToHashSet() | 10000 | 50 | 100 | 43,938.46 μs | 994.200 μs | 2,687.877 μs | 42,877.97 μs |
| prebuilt HashSet | 10000 | 50 | 100 | 4,634.98 μs | 16.757 μs | 15.675 μs | 4,643.17 μs |
| All(=>Contains) | 10000 | 50 | 100 | 10,256.62 μs | 26.440 μs | 24.732 μs | 10,243.34 μs |
| Except().Any() | 10000 | 50 | 10000 | 73,192.15 μs | 479.584 μs | 425.139 μs | 73,077.26 μs |
| ToHashSet() | 10000 | 50 | 10000 | 45,880.72 μs | 141.497 μs | 125.433 μs | 45,860.50 μs |
| prebuilt HashSet | 10000 | 50 | 10000 | 1,620.61 μs | 3.507 μs | 3.280 μs | 1,620.52 μs |
| All(=>Contains) | 10000 | 50 | 10000 | 1,460.01 μs | 1.819 μs | 1.702 μs | 1,459.49 μs |
| Except().Any() | 100000 | 10 | 100 | 149,047.91 μs | 1,696.388 μs | 1,586.803 μs | 149,063.20 μs |
| ToHashSet() | 100000 | 10 | 100 | 100,657.74 μs | 150.890 μs | 117.805 μs | 100,654.39 μs |
| prebuilt HashSet | 100000 | 10 | 100 | 12,753.33 μs | 17.257 μs | 15.298 μs | 12,749.85 μs |
| All(=>Contains) | 100000 | 10 | 100 | 11,238.79 μs | 54.228 μs | 50.725 μs | 11,247.03 μs |
| Except().Any() | 100000 | 10 | 10000 | 163,277.55 μs | 1,096.107 μs | 1,025.299 μs | 163,556.98 μs |
| ToHashSet() | 100000 | 10 | 10000 | 99,927.78 μs | 403.811 μs | 337.201 μs | 99,812.12 μs |
| prebuilt HashSet | 100000 | 10 | 10000 | 11,671.99 μs | 6.753 μs | 5.986 μs | 11,672.28 μs |
| All(=>Contains) | 100000 | 10 | 10000 | 8,217.51 μs | 67.959 μs | 56.749 μs | 8,225.85 μs |
| Except().Any() | 100000 | 50 | 100 | 493,925.76 μs | 2,169.048 μs | 1,922.805 μs | 493,386.70 μs |
| ToHashSet() | 100000 | 50 | 100 | 432,214.15 μs | 1,261.673 μs | 1,180.169 μs | 431,624.50 μs |
| prebuilt HashSet | 100000 | 50 | 100 | 49,593.29 μs | 75.300 μs | 66.751 μs | 49,598.45 μs |
| All(=>Contains) | 100000 | 50 | 100 | 98,662.71 μs | 119.057 μs | 111.366 μs | 98,656.00 μs |
| Except().Any() | 100000 | 50 | 10000 | 733,526.81 μs | 8,728.516 μs | 8,164.659 μs | 733,455.20 μs |
| ToHashSet() | 100000 | 50 | 10000 | 460,166.27 μs | 7,227.011 μs | 6,760.150 μs | 457,359.70 μs |
| prebuilt HashSet | 100000 | 50 | 10000 | 17,443.96 μs | 10.839 μs | 9.608 μs | 17,443.40 μs |
| All(=>Contains) | 100000 | 50 | 10000 | 14,222.31 μs | 47.090 μs | 44.048 μs | 14,217.94 μs |
于 2020-10-17T10:07:39.327 回答
1
基于@Cameron 和@Neil 的答案，我编写了一个扩展方法，该方法使用与 Enumerable 类相同的术语。
/// <summary>
/// Determines whether a sequence contains the specified elements by using the default equality comparer.
/// </summary>
/// <typeparam name="TSource">The type of the elements of source.</typeparam>
/// <param name="source">A sequence in which to locate the values.</param>
/// <param name="values">The values to locate in the sequence.</param>
/// <returns>true if the source sequence contains elements that have the specified values; otherwise, false.</returns>
public static bool ContainsAll<TSource>(this IEnumerable<TSource> source, IEnumerable<TSource> values)
{
return !values.Except(source).Any();
}
于 2017-10-23T08:41:20.357 回答
0
那么我们有 2 个数组，array1并且array2我们想要检查所有array1值是否存在于array2：
array1.All(ar1 => array2.Any(ar2 => ar2.Equals(ar1)));
注意：ar2.Equals(ar1)如果以其他方式描述相等，则可以替换。
于 2020-11-04T14:16:33.677 回答
-1
试试这个
static bool IsSubSet<A>(A[] set, A[] toCheck) {
return set.Length == (toCheck.Intersect(set)).Count();
}
这里的想法是 Intersect 只会返回两个数组中的值。此时如果结果集的长度与原始集相同，则“set”中的所有元素也都在“check”中，因此“set”是“toCheck”的子集
注意：如果“set”有重复项，我的解决方案将不起作用。我不会改变它，因为我不想窃取别人的选票。
提示：我投票支持卡梅伦的回答。
于 2008-12-02T03:44:56.090 回答
-1
在这里，我们检查子列表（即
t2）中是否存在任何不包含在父列表（即t1）中的元素。如果不存在，则该列表是另一个列表的子集
例如：
bool isSubset = !(t2.Any(x => !t1.Contains(x)));
于 2018-06-07T04:11:54.040 回答