Vector 从Rust中的向量构建哈希集

我想从一个

Vec

构建一个

HashSet

。我想这样做

在一行代码中

只复制一次数据

仅使用

2n

内存

但我能编译的唯一东西就是这段。。垃圾，我认为它会复制数据两次并使用

3n

内存

fn vec_to_set(vec: Vec<u8>) -> HashSet<u8> {
    let mut victim = vec.clone();
    let x: HashSet<u8> = victim.drain(..).collect();
    return x;
}

fn-vec-to-set（vec:vec）->HashSet{
让mut-victor=vec.clone（）；
设x:HashSet=牺牲品.drain（..）.collect（）；
返回x；
}

我希望写一些简单的东西，比如：

fn vec_to_set(vec: Vec<u8>) -> HashSet<u8> {
    return HashSet::from_iter(vec.iter());
}

fn-vec-to-set（vec:vec）->HashSet{
返回HashSet:：from_iter（vec.iter（））；
}

但这不会编译：

错误[E0308]：类型不匹配
--> :5:12
|
5 |返回HashSet:：from_iter（vec.iter（））；
|^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^预期的u8，已找到的和u8
|
=注意：应为'std:：collections:：HashSet'类型`
=注意：找到类型`std:：collections:：HashSet`

---

。。我不太理解错误信息，可能是因为我需要RTFM。

以下应该可以很好地工作；它满足您的要求：

use std::collections::HashSet;
use std::iter::FromIterator;

fn vec_to_set(vec: Vec<u8>) -> HashSet<u8> {
    HashSet::from_iter(vec)
}

使用std:：collections:：HashSet；
使用std:：iter:：FromIterator；
fn vec_到_集（vec:vec）->HashSet{
HashSet:：来自iter（vec）
}

from_iter（）

用于实现类型，因此

Vec

参数就足够了

补充说明：

• 您不需要显式地

  返回

  函数结果；只需在其主体的最后一个表达式中省略分号

• 我不确定您使用的是哪个版本的Rust，但在当前的stable（1.12）

  to_iter（）

  上不存在

---

因为操作不需要消耗向量，所以我认为它不应该消耗向量。这只会导致在程序中的其他地方进行额外复制：

use std::collections::HashSet;
use std::iter::FromIterator;

fn hashset(data: &[u8]) -> HashSet<u8> {
    HashSet::from_iter(data.iter().cloned())
}

使用std:：collections:：HashSet；
使用std:：iter:：FromIterator；
fn哈希集（数据：&[u8]）->哈希集{
HashSet:：from_iter（data.iter（）.cloned（））
}

将其称为

hashset（&v）

，其中

v

是一个

Vec

或其他强制到切片的东西

当然，有更多的方法来写这篇文章，是泛型的，等等，但是这个答案坚持只介绍我想关注的东西

这是基于元素类型

u8

是

Copy

，即它没有所有权语义。

移动数据所有权

let vec: Vec<usize> = vec![1, 2, 3, 4];
let hash_set: HashSet<usize> = vec.into_iter().collect();

让vec:vec=vec！[1, 2, 3, 4];
让hash_set:HashSet=vec.into_iter（）.collect（）；

克隆数据

let vec: Vec<usize> = vec![1, 2, 3, 4];
let hash_set: HashSet<usize> = vec.iter().cloned().collect();

让vec:vec=vec！[1, 2, 3, 4];
让hash_set:HashSet=vec.iter（）.cloned（）.collect（）；

FYI：在第一个代码中，不需要克隆向量，只需将其声明为可变。通过

让mut受害者=vec

或参数列表中的by:

fn vec\u to_set（mut vec:vec）

。您没有正确使用O表示法。O（n）=O（2n）=O（3n）=O（c*n）。关键是常数并不重要。我想你的意思很清楚，但你可能应该说“2n内存”或其他什么。谢谢Lii，如果

O（n）==O（2n）

那么什么是正确的方式来表达某件事情需要两倍的时间？能够比较

n

和

2n

似乎很有用。谢谢。

collect

使用来自迭代器的

fromtiterator

-这与上述两个答案相同，只是更详细。修复了类型错误。此代码不需要在转换代码中重复HashSet在原始答案中也不重复

HashSet

。他们的代码：

let hash_set=HashSet:：：来自iter（vec）

vs yours:

let hash\u set:HashSet=vec.into\u iter（）.collect（）

您在第一个示例中删除了类型以隐藏HashSet代码1的重复：

let hash\u set:HashSet=HashSet:：：from\u iter（vec）代码2:
让hash\u set:HashSet=vec.into\u iter（）.collect（）
示例恢复此示例不再编译。对我来说效果很好