Rust 是否有一个内置函数来计算两个集合的差？

刚生锈的。这个问题很简单，我搜索了一会儿，没有找到答案

基本上我想要这样的东西

let mut v1 = vec![0, 1, 2, 3, 4];
let mut v2 = vec![3, 4];
assert_eq!(v1 - v2, &[0, 1, 2]);

let mut v1 = vec![0, 1, 2, 3, 4, 5, 6];
let mut v2 = vec![3, 4];
assert_eq!(v1 - v2, &[0, 1, 2, 5, 6]);

let mut v1 = vec![0, 1, 2, 3, 4, 5, 6];
let mut v2 = vec![7];
assert_eq!(v1 - v2, &[0, 1, 2, 3, 4, 5, 6]);

---

根据您的示例，您似乎在寻找元素唯一的向量

向量实际上并不能保证这个属性（项不必是唯一的或有序的，事实上，它们甚至不必支持比较），但集合可以（或）。HashSet确实支持

-

操作符：

（）

使用std:：collections:：HashSet；
fn main（）{
让s1:HashSet=[0,1,2,3,4].iter（）.cloned（）.collect（）；
设s2:HashSet=[3,4].iter（）.cloned（）.collect（）；
应为：HashSet=[0,1,2].iter（）.cloned（）.collect（）；
断言（s1-&s2，预期值）；
}

如果要对向量执行此操作，可以将其转换为HashSet或Btreset，然后根据以下内容创建向量：

fn向量差异（v1:&Vec，v2:&Vec）->Vec{
设s1:HashSet=v1.iter（）.cloned（）.collect（）；
设s2:HashSet=v2.iter（）.cloned（）.collect（）；
（&s1-&s2）.iter（）.cloned（）.collect（））
}

或者，您可以直接在向量上执行差分（请记住，这是一个O（N*M）算法，如果两个向量都很长，则执行效果会很差）：

fn向量差异（v1:&Vec，v2:&Vec）->Vec{
v1.iter（）.filter（|&x |！v2.contains（x））.cloned（）.collect（）
}

要从一个向量中删除另一个向量中的元素：

fn减法（a:&Vec，b:&Vec）->Vec{
设mut c=a.clone（）；
c、 保留（| x |！b.包含（x））；
C
}

或者如果你对变异第一个向量没意见：

fn减法（a:&mut向量，b:&Vec）{
a、 保留（| x |！b.包含（x））；
}

注意这是一个O（N*M）算法，其中N，M是向量的长度

这对于少量元素来说是快速的。对于较大的数字，您可以使用

哈希集

。该方法提供了一个适用的示例，首先从向量构建集合

这是我的版本，它只生成一个

HashSet

，因此，如果从两个向量开始，并希望以一个向量结束，则速度更快。这与

difference（）

在发动机罩下的作用类似

使用std:：collections:：HashSet；
设b:HashSet=v2.into_iter（）.collect（）；
v1.保留（| x |！b.包含（x））；

---

这将是O（M+N）：M用于从第二个向量构建哈希集，N用于检查第一个向量中的每个元素。

还不完全清楚该如何工作。如果

v2

不是

v1

的后缀，该怎么办？我添加了更多的示例没有设置扇区，因此这样的操作效率不高，也没有定义。相反，请参见。从示例中可以看出，您希望从第一个向量中删除两个向量中的元素。对于大量元素，集合将是一种很好的方法。对于较小的数字，向量是可以接受的，甚至可以更快。对于

[1,1,2,2]-[1,2]

的预期结果是什么？顺序重要吗？对于函数参数，最好使用片

&[T]

而不是向量

&Vec

。对vec的共享引用在访问数据时增加了不必要的间接性，与

和[t]

相比没有任何好处。另一方面，切片可以从任何连续存储的数据中获得，而不仅仅是向量中的数据。完全同意重新切片与向量。我希望保持示例Vec的重点，因为OP正在处理这个问题。我认为这始终是一个问题，即在帖子中加入多少最佳实践-也许在这里使用

&[T]

会更好，但有时你会以这种方式解释太多的要点…@Paul根据v2的长度，可能值得将其转换为预先设置，以避免支付O（n）v1中每个元素的成员查找。很公平。我想我应该让post接受

&[i32]

，而不做专门的解释，因为切片足够基本，任何生锈教程都会涵盖它们。但是，正如你所知道的最佳实践，这只是品味的问题。