查看本地官方文档
安装rust后运行
rustup doc
查看The Standard Library即可获取标准库内容
std::collections::BinaryHeap定义
大根堆（任一节点大于其子节点的值），每次更改堆结构都会重新维护为大根堆
BinaryHeap定义
pub struct BinaryHeap<T, A: Allocator = Global> {
data: Vec<T, A>,
}
方法
with_capacity：创建一个具有指定初始容量的BinaryHeap
use std::collections::BinaryHeap;
fn main() {
let heap: BinaryHeap<i32> = BinaryHeap::with_capacity(5);
println!("Initial capacity: {}", heap.capacity());
// Initial capacity: 5
}
peek_mut：返回一个可变引用，指向堆顶元素（最大值，对于max - heap类型的BinaryHeap）
use std::collections::BinaryHeap;
fn main() {
let mut heap = BinaryHeap::from([1, 2, 3]);
if let Some(mut top) = heap.peek_mut() {
*top = 4;
}
println!("Heap after peek_mut: {:?}", heap);
// Heap after peek_mut: [4, 2, 1]
}
pop：移除并返回堆顶元素（最大值，对于max - heap类型的BinaryHeap）。在弹出元素后，堆会自动重新调整以保持堆的性质
use std::collections::BinaryHeap;
fn main() {
let mut heap = BinaryHeap::from([1, 2, 3]);
if let Some(top) = heap.pop() {
println!("Popped element: {}", top);
// Popped element: 3
}
println!("Heap after pop: {:?}", heap);
// Heap after pop: [2, 1]
}
push：向BinaryHeap中插入一个新元素。插入后，堆会自动重新调整结构以保持堆的性质（例如，对于max - heap，新元素会 “上浮” 到合适的位置，使得父节点的值大于等于子节点的值）
use std::collections::BinaryHeap;
fn main() {
let mut heap = BinaryHeap::new();
heap.push(3);
heap.push(1);
heap.push(2);
println!("Heap after pushes: {:?}", heap);
// Heap after pushes: [3, 1, 2]
}
into_sorted_vec：将BinaryHeap转换为一个已排序的向量。这个操作会消耗BinaryHeap，并返回一个包含堆中所有元素的Vec，其中元素按照从小到大（对于min - heap）或从大到小（对于max - heap）的顺序排列
use std::collections::BinaryHeap;
fn main() {
let heap = BinaryHeap::from([3, 1, 2]);
let sorted_vec = heap.into_sorted_vec();
println!("Sorted vector: {:?}", sorted_vec);
// Sorted vector: [1, 2, 3]
}
append：将另一个BinaryHeap中的所有元素移动到当前BinaryHeap中。在操作完成后，另一个BinaryHeap变为空，并且当前BinaryHeap会重新调整结构以保持堆的性质
use std::collections::BinaryHeap;
fn main() {
let mut heap1 = BinaryHeap::from([1, 2]);
let mut heap2 = BinaryHeap::from([3, 4]);
heap1.append(&mut heap2);
println!("Heap1 after append: {:?}", heap1);
// Heap1 after append: [4, 3, 2, 1]
println!("Heap2 after append: {:?}", heap2);
// Heap2 after append: []
}
retain：保留满足给定谓词的元素，移除不满足的元素。在移除元素后，堆会自动重新调整以保持堆的性质
use std::collections::BinaryHeap;
fn main() {
let mut heap = BinaryHeap::from([1, 2, 3, 4, 5]);
heap.retain(|&x| x % 2 == 0);
println!("Heap after retain: {:?}", heap);
// Heap after retain: [4, 2]
}
iter：返回一个迭代器，用于遍历BinaryHeap中的元素。迭代顺序是按照堆的遍历顺序（通常不是排序后的顺序）
use std::collections::BinaryHeap;
fn main() {
let heap = BinaryHeap::from([3, 1, 2]);
for element in heap.iter() {
println!("Element: {}", element);
}
// Element: 3
// Element: 1
// Element: 2
}
peek：返回一个不可变引用，指向堆顶元素（最大值，对于max - heap类型的BinaryHeap）。如果堆为空，则返回None。这个方法可以用于查看堆顶元素的值，而不弹出它
use std::collections::BinaryHeap;
fn main() {
let heap = BinaryHeap::from([3, 1, 2]);
if let Some(top) = heap.peek() {
println!("Peeked element: {}", top);
// Peeked element: 3
}
}
capacity：返回BinaryHeap当前的容量，即它在不重新分配内存的情况下能够容纳的元素数量
use std::collections::BinaryHeap;
fn main() {
let mut heap: BinaryHeap<i32> = BinaryHeap::with_capacity(5);
println!("Initial capacity: {}", heap.capacity());
heap.push(1);
// Initial capacity: 5
println!("Capacity after push: {}", heap.capacity());
// Capacity after push: 5
}
reserve_exact：精确地预留足够的空间以容纳指定数量的额外元素。这试图最小化内存浪费，但可能需要更多的计算来确定准确的预留空间大小
use std::collections::BinaryHeap;
fn main() {
let mut heap = BinaryHeap::new();
heap.reserve_exact(3);
println!("Capacity after reserve_exact: {}", heap.capacity());
// Capacity after reserve_exact: 3
heap.push(1);
heap.push(2);
heap.push(3);
}
reserve：预留足够的空间以容纳指定数量的额外元素。这个方法可能会预留比实际需要更多的空间，以减少频繁的内存重新分配
use std::collections::BinaryHeap;
fn main() {
let mut heap = BinaryHeap::new();
heap.reserve(5);
println!("Capacity after reserve: {}", heap.capacity());
// Capacity after reserve: 5
heap.push(1);
heap.push(2);
heap.push(3);
}
try_reserve_exact：尝试精确地预留足够的空间以容纳指定数量的额外元素。如果成功，返回Ok(())，否则返回一个错误，表示无法预留足够的空间
use std::collections::BinaryHeap;
fn main() {
let mut heap = BinaryHeap::new();
if let Ok(()) = heap.try_reserve_exact(3) {
println!("Reserved successfully. Capacity: {}", heap.capacity());
// Reserved successfully. Capacity: 3
} else {
println!("Reserve failed.");
}
heap.push(1);
heap.push(2);
heap.push(3);
}
try_reserve：尝试预留足够的空间以容纳指定数量的额外元素。如果成功，返回Ok(())，否则返回一个错误，表示无法预留足够的空间
use std::collections::BinaryHeap;
fn main() {
let mut heap = BinaryHeap::new();
if let Ok(()) = heap.try_reserve(5) {
println!("Reserved successfully. Capacity: {}", heap.capacity());
// Reserved successfully. Capacity: 5
} else {
println!("Reserve failed.");
}
heap.push(1);
heap.push(2);
heap.push(3);
}
shrink_to_fit：将BinaryHeap的容量收缩到与当前元素数量相同。这可以释放多余的内存空间，但可能会涉及到重新分配内存和调整堆结构的操作
use std::collections::BinaryHeap;
fn main() {
let mut heap = BinaryHeap::with_capacity(10);
heap.push(1);
heap.push(2);
heap.push(3);
heap.shrink_to_fit();
println!("Capacity after shrink_to_fit: {}", heap.capacity());
// Capacity after shrink_to_fit: 3
}
shrink_to：将BinaryHeap的容量收缩到与当前元素数量相同。这可以释放多余的内存空间，但可能会涉及到重新分配内存和调整堆结构的操作
use std::collections::BinaryHeap;
fn main() {
let mut heap = BinaryHeap::with_capacity(10);
heap.push(1);
heap.push(2);
heap.push(3);
heap.shrink_to(5);
println!("Capacity after shrink_to: {}", heap.capacity());
// Capacity after shrink_to: 5
}
as_slice：返回一个不可变切片，包含BinaryHeap中的所有元素。这个切片的顺序是按照堆的内部存储顺序，不是排序后的顺序
use std::collections::BinaryHeap;
fn main() {
let heap = BinaryHeap::from([3, 1, 2]);
let slice = heap.as_slice();
println!("Slice: {:?}", slice);
// Slice: [3, 1, 2]
}
into_vec：将BinaryHeap转换为一个Vec，堆中的元素顺序是按照堆的内部存储顺序，不是排序后的顺序。这个操作会消耗BinaryHeap
use std::collections::BinaryHeap;
fn main() {
let heap = BinaryHeap::from([3, 1, 2]);
let vec = heap.into_vec();
println!("Vector: {:?}", vec);
// Vector: [3, 1, 2]
}
len：返回BinaryHeap中元素的数量
use std::collections::BinaryHeap;
fn main() {
let heap = BinaryHeap::from([3, 1, 2]);
println!("Length of the heap: {}", heap.len());
// Length of the heap: 3
}
is_empty：判断BinaryHeap是否为空
use std::collections::BinaryHeap;
fn main() {
let heap: BinaryHeap<i32> = BinaryHeap::new();
println!("Is the heap empty? {}", heap.is_empty());
// Is the heap empty? true
let heap2 = BinaryHeap::from([1]);
println!("Is heap2 empty? {}", heap2.is_empty());
// Is heap2 empty? false
}
drain：创建一个迭代器，用于移除并返回BinaryHeap中的元素。这个操作会消耗BinaryHeap中的元素，并且在迭代过程中可以对每个元素进行操作
use std::collections::BinaryHeap;
fn main() {
let mut heap = BinaryHeap::from([3, 1, 2]);
let drained = heap.drain().collect::<Vec<i32>>();
println!("Drained elements: {:?}", drained);
// Drained elements: [3, 1, 2]
println!("Heap after drain: {:?}", heap);
// Heap after drain: []
}
clear：清空BinaryHeap，移除所有元素
use std::collections::BinaryHeap;
fn main() {
let mut heap = BinaryHeap::from([3, 1, 2]);
println!("Before clearing: {:?}", heap);
// Before clearing: [3, 1, 2]
heap.clear();
println!("After clearing: {:?}", heap);
// After clearing: []
}
