Rust中的集合Collection

集合（Collections）是存储多个值的数据结构，主要存放在标准库std::collections模块中。集合的大小可以动态变化，且数据通常存储在堆上。

Rust标准库中主要集合类型有：

类型	名称	说明
Vec<T>	动态数组	元素有序、可变长、随机访问高效
VecDeque<T>	双端队列	支持两端高效插入/删除
LinkedList<T>	双向链表	插入删除快，随机访问慢
HashMap<K,V>	哈希表	基于哈希的键值存储，无序
BTreeMap<K,V>	平衡树映射	基于排序的键值存储，有序
HashSet<T>	哈希集合	不重复元素，无序
BTreeSet<T>	有序集合	不重复元素，有序
BinaryHeap<T>	堆结构	可用于优先队列（最大堆）

动态数组Vec

Vec<T>是 Rust 中最常用的集合，本质是动态数组，支持在末尾高效插入 / 删除元素，且可通过索引随机访问。

创建方式：

let v1 = Vec::new(); // 空 vector
let v2 = vec![1, 2, 3]; // 宏创建
let mut v3 = Vec::with_capacity(10); // 预分配容量

常用方法：

方法	说明	返回值
new()	创建空向量	Vec<T>
with_capacity(n)	预分配容量	Vec<T>
push(value)	末尾添加元素	()
pop()	移除最后一个元素	Option<T>
insert(index, value)	在指定位置插入	()
remove(index)	移除指定位置	T
clear()	清空所有元素	()
len()	返回长度	usize
capacity()	返回容量	usize
reserve(n)	扩容	()
shrink_to_fit()	收缩容量	()
get(i)	安全访问元素	Option<&T>
get_mut(i)	可变访问元素	Option<&mut T>
first() / last()	获取首/尾元素	Option<&T>
iter() / iter_mut()	遍历元素	迭代器
sort() / sort_by()	排序	()

双端队列VecDeque

VecDeque<T>（Double-ended Queue）是双端队列，底层使用环形缓冲区实现。支持在首尾两端高效插入 / 删除元素，内部基于环形缓冲区实现。

use std::collections::VecDeque;
let mut deque = VecDeque::new();
deque.push_back(2);
deque.push_front(1);
deque.pop_front(); // 移除首元素

常用方法：

方法	说明	返回值
new()	创建空队列	VecDeque<T>
with_capacity(n)	预分配容量	VecDeque<T>
push_back(value)	末尾入队	()
push_front(value)	头部入队	()
pop_back()	从尾部出队	Option<T>
pop_front()	从头部出队	Option<T>
front() / back()	查看首尾元素	Option<&T>
len() / is_empty()	长度/是否空	usize / bool
get(i)	安全索引访问	Option<&T>
iter() / iter_mut()	遍历	迭代器
rotate_left(k) / rotate_right(k)	循环旋转	()

双向链表LinkedList

LinkedList<T>是双向链表，元素通过指针连接，不连续存储。

• 实际性能较差：因元素不连续，缓存友好性低，随机访问效率低（O (n)）。
• 极少使用（除非明确需要链表的理论特性，否则优先用Vec或VecDeque）。

use std::collections::LinkedList;

let mut list = LinkedList::new();
list.push_back(1);     // 尾部添加：[1]
list.push_front(0);    // 头部添加：[0, 1]
list.pop_back();       // 尾部移除：返回Some(1)
list.pop_front();      // 头部移除：返回Some(0)

常用方法：

方法	说明	返回值
new()	创建空链表	LinkedList<T>
push_back(value)	尾部插入	()
push_front(value)	头部插入	()
pop_back() / pop_front()	移除首/尾	Option<T>
front() / back()	获取首尾引用	Option<&T>
len() / is_empty()	获取长度 / 是否为空	usize / bool
clear()	清空链表	()
append(&mut other)	拼接另一个链表	()
iter() / iter_mut()	遍历	迭代器

哈希表HashMap<K,V>

HashMap<K, V>基于哈希表实现，通过哈希函数将键映射到存储位置，查询和插入的平均时间复杂度为 O (1):

• 无序存储（键的顺序不固定）。
• 键K需实现Hash和Eq trait（用于哈希计算和相等性比较）。
• 性能依赖哈希函数的质量（避免哈希冲突）。

use std::collections::HashMap;

// 1. 基本创建
let mut scores = HashMap::new();
scores.insert(String::from("Alice"), 90);
scores.insert(String::from("Bob"), 85);

// 2. 从迭代器创建
let teams = vec![String::from("Blue"), String::from("Red")];
let initial_scores = vec![10, 50];
let scores: HashMap<_, _> = teams.into_iter().zip(initial_scores.into_iter()).collect();

常用方法：

方法	说明	返回值
new()	创建空映射	HashMap<K,V>
with_capacity(n)	预分配容量	HashMap<K,V>
insert(key, val)	插入或更新键值	Option<V>（旧值）
remove(key)	删除键	Option<V>
get(key)	获取值引用	Option<&V>
get_mut(key)	可变引用	Option<&mut V>
contains_key(key)	是否存在	bool
entry(key)	获取或创建 entry	Entry<K,V>
len() / is_empty()	长度 / 是否空	usize / bool
keys() / values() / iter()	迭代键、值、键值对	迭代器
clear()	清空	()

有序映射BTreeMap<K,V>

BTreeMap<K, V>基于 B 树实现，键值对按键的排序顺序存储，查询时间复杂度为 O (log n)。

• 键值对按键的自然顺序（或自定义排序）有序存储。
• 键K需实现Ord trait（用于排序）。
• 支持范围查询（如获取 “大于 x 且小于 y” 的键值对）。

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(3, "c");
map.insert(1, "a");
map.insert(2, "b");

// 遍历：按键的升序输出 (1,"a"), (2,"b"), (3,"c")
for (k, v) in &map {
    println!("{}: {}", k, v);
}

// 范围查询：获取键 >1 且 <=3 的键值对
let range = map.range(1..=3);  // 包含1和3

常用方法：

方法	说明	返回值
new()	创建空映射	BTreeMap<K,V>
insert(key, val)	插入或替换	Option<V>
remove(key)	删除键	Option<V>
get(key)	获取引用	Option<&V>
contains_key(key)	检查存在	bool
len() / is_empty()	长度 / 空	usize / bool
iter()	遍历有序键值	迭代器
range(range)	范围遍历	迭代器
first_key_value() / last_key_value()	最小/最大键	Option<(&K,&V)>
clear()	清空	()

哈希集合HashSet

HashSet<T>基于HashMap<T, ()>实现，存储唯一元素，无序。

• 元素唯一（插入重复元素会被忽略）。
• 元素T需实现Hash和Eq trait。
• 插入、查询、删除的平均时间复杂度为 O (1)。

use std::collections::HashSet;

let mut set = HashSet::new();
set.insert(1);
set.insert(2);
set.insert(1);  // 重复元素，插入失败

// 常用方法
let has_one = set.contains(&1);  // true
let removed = set.remove(&1);    // true，移除1
let len = set.len();             // 1（剩余元素2）

常用方法：

方法	说明	返回值
new()	创建空集合	HashSet<T>
insert(value)	插入	bool（是否新插入）
remove(value)	删除	bool
contains(value)	是否存在	bool
len() / is_empty()	长度 / 空	usize / bool
clear()	清空	()
iter()	遍历	迭代器
union(&other)	并集	迭代器
intersection(&other)	交集	迭代器
difference(&other)	差集	迭代器
symmetric_difference(&other)	对称差	迭代器

有序集合BTreeSet

BTreeSet<T>基于BTreeMap<T, ()>实现，存储唯一元素，且按元素顺序排序。

• 元素唯一且有序（按Ord trait 排序）。
• 元素T需实现Ord trait。
• 支持范围查询，查询时间复杂度为 O (log n)。

use std::collections::BTreeSet;

let mut set = BTreeSet::new();
set.insert(3);
set.insert(1);
set.insert(2);

// 遍历：按顺序输出 1, 2, 3
for num in &set {
    println!("{}", num);
}

// 范围查询：获取 >1 且 <=3 的元素
let range = set.range(1..=3);  // 包含1和3

常用方法：

方法	说明	返回值
new()	创建空集合	BTreeSet<T>
insert(value)	插入	bool
remove(value)	删除	bool
contains(value)	是否存在	bool
len() / is_empty()	长度 / 空	usize / bool
iter()	遍历有序元素	迭代器
range(range)	范围遍历	迭代器
first() / last()	最小 / 最大元素	Option<&T>
union(&other) / intersection(&other)	集合操作	迭代器

二叉堆BinaryHeap

实现优先队列功能 :

• 默认是 最大堆；
• 可通过 Reverse() 包装改为最小堆。

use std::cmp::Reverse;
let mut min_heap = BinaryHeap::new();
min_heap.push(Reverse(10));
min_heap.push(Reverse(5));

println!("{}", min_heap.pop().unwrap().0); // 5

常用方法：

方法	说明	返回值
new()	创建空堆	BinaryHeap<T>
from(vec)	从 Vec 构建堆	BinaryHeap<T>
push(value)	插入元素	()
pop()	弹出最大元素	Option<T>
peek()	查看最大元素	Option<&T>
len() / is_empty()	长度 / 空	usize / bool
clear()	清空	()
into_sorted_vec()	升序取出所有元素	Vec<T>
drain_sorted()	按排序迭代出元素	迭代器