Struct BinHeap

pub struct BinHeap<T>
where
    T: Ord,
{ /* private fields */ }

About

It’s Vec with a brand new dress.

See the module-level documentation for more information.

Implementations

impl<T> BinHeap<T>

where T: Ord,

pub fn new() -> Self

Creates a new, zero-sized BinHeap.

pub fn new_with_capacity(capacity: usize) -> Self

Creates a new BinHeap that pre-allocates to the given capacity.

pub fn from_slice(list: &[T]) -> Self

where T: Clone,

A “heapify” operation that creates a BinHeap from any slice of entries in O(n) time. The entries must be Clone.

pub fn from_vec(list: Vec<T>) -> Self

A “heapify” operation that creates a BinHeap from a Vec<T> in O(n) time. T does not need to be Clone.

pub fn size(&self) -> usize

Returns the number of elements in the heap.

pub fn push(&mut self, data: T)

Adds an element to the heap in O(log(n)) time.

pub fn peek(&self) -> Option<&T>

Returns an immutable reference to the data at the top of the heap in O(1) time.

pub fn pop(&mut self) -> Option<T>

Returns and removes the element at the top of the heap in O(log(n)) time.

pub fn heap_sort(list: &mut [T])

where T: Ord,

Sorts a mutable slice into ascending order in place via (max) heap operations in O(n * log(n)) time.

use dsa_rust::hierarchies::bin_heap::BinHeap;
let mut v = Vec::from([8, 6, 7, 5, 3, 0, 9]);
BinHeap::heap_sort(&mut v);
assert_eq!(v, [0, 3, 5, 6, 7, 8, 9]);

Trait Implementations

impl<T> Debug for BinHeap<T>

where T: Ord + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for BinHeap<T>

where T: Ord,

fn default() -> Self

Returns the “default value” for a type.