Rust 中常用的集合类型 (Collections) 有哪些？

推荐答案

Rust 中常用的集合类型包括：

• Vec<t>: 动态数组，允许存储多个相同类型的元素，并且可以动态调整大小。
• VecDeque<t>: 双端队列，允许从队列的前端和后端高效地添加或移除元素。
• LinkedList<t>: 双向链表，适合频繁的插入和删除操作。
• HashMap<K, V>: 基于哈希表的键值对集合，允许通过键快速查找值。
• BTreeMap<K, V>: 基于平衡二叉树的键值对集合，键值对按顺序存储。
• HashSet<t>: 基于哈希表的集合，存储唯一的元素。
• BTreeSet<t>: 基于平衡二叉树的集合，元素按顺序存储且唯一。
• BinaryHeap<t>: 优先队列，通常用于实现最大堆或最小堆。

本题详细解读

Vec<t>

Vec<T> 是 Rust 中最常用的集合类型之一。它是一个动态数组，可以在运行时动态调整大小。Vec<T> 提供了高效的随机访问和尾部插入操作，但在中间插入或删除元素时性能较差。

let mut v = Vec::new();
v.push(1);
v.push(2);
println!("{:?}", v); // 输出: [1, 2]

VecDeque<t>

VecDeque<T> 是一个双端队列，允许从队列的前端和后端高效地添加或移除元素。它适合需要频繁在两端进行操作的场景。

use std::collections::VecDeque;

let mut deque = VecDeque::new();
deque.push_back(1);
deque.push_front(0);
println!("{:?}", deque); // 输出: [0, 1]

LinkedList<t>

LinkedList<T> 是一个双向链表，适合频繁的插入和删除操作。由于链表的特性，它在随机访问时性能较差。

use std::collections::LinkedList;

let mut list = LinkedList::new();
list.push_back(1);
list.push_front(0);
println!("{:?}", list); // 输出: [0, 1]

HashMap<K, V>

HashMap<K, V> 是一个基于哈希表的键值对集合，允许通过键快速查找值。它的查找、插入和删除操作的平均时间复杂度为 O(1)。

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert("key1", "value1");
map.insert("key2", "value2");
println!("{:?}", map.get("key1")); // 输出: Some("value1")

BTreeMap<K, V>

BTreeMap<K, V> 是一个基于平衡二叉树的键值对集合，键值对按顺序存储。它的查找、插入和删除操作的时间复杂度为 O(log n)。

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "value1");
map.insert(2, "value2");
println!("{:?}", map.get(&1)); // 输出: Some("value1")

HashSet<t>

HashSet<T> 是一个基于哈希表的集合，存储唯一的元素。它的查找、插入和删除操作的平均时间复杂度为 O(1)。

use std::collections::HashSet;

let mut set = HashSet::new();
set.insert(1);
set.insert(2);
println!("{:?}", set.contains(&1)); // 输出: true

BTreeSet<t>

BTreeSet<T> 是一个基于平衡二叉树的集合，元素按顺序存储且唯一。它的查找、插入和删除操作的时间复杂度为 O(log n)。

use std::collections::BTreeSet;

let mut set = BTreeSet::new();
set.insert(1);
set.insert(2);
println!("{:?}", set.contains(&1)); // 输出: true

BinaryHeap<t>

BinaryHeap<T> 是一个优先队列，通常用于实现最大堆或最小堆。它允许高效地获取和移除最大或最小元素。

use std::collections::BinaryHeap;

let mut heap = BinaryHeap::new();
heap.push(1);
heap.push(2);
println!("{:?}", heap.pop()); // 输出: Some(2)