Struct BinaryHeap

pub struct BinaryHeap<T, C = MaxComparator>
where
    C: Compare<T>,
{
    pub data: Vec<T>,
    /* private fields */
}

Fields

data: Vec<T>

Implementations

impl<T, C: Compare<T> + Default> BinaryHeap<T, C>

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

impl<T, C: Compare<T>> BinaryHeap<T, C>

pub fn from_vec_cmp(vec: Vec<T>, cmp: C) -> Self

pub unsafe fn from_vec_cmp_raw(vec: Vec<T>, cmp: C, rebuild: bool) -> Self

impl<T: Ord> BinaryHeap<T>

pub fn new() -> Self

pub fn with_capacity(capacity: usize) -> Self

impl<T: Ord> BinaryHeap<T, MinComparator>

pub fn new_min() -> Self

pub fn with_capacity_min(capacity: usize) -> Self

impl<T, F> BinaryHeap<T, FnComparator<F>>

where F: Fn(&T, &T) -> Ordering,

pub fn new_by(f: F) -> Self

pub fn with_capacity_by(capacity: usize, f: F) -> Self

impl<T, F, K: Ord> BinaryHeap<T, KeyComparator<F>>

where F: Fn(&T) -> K,

pub fn new_by_key(f: F) -> Self

pub fn with_capacity_by_key(capacity: usize, f: F) -> Self

impl<T, C: Compare<T>> BinaryHeap<T, C>

pub fn replace_cmp(&mut self, cmp: C)

pub unsafe fn replace_cmp_raw(&mut self, cmp: C, rebuild: bool)

pub fn iter(&self) -> Iter<'_, T>

pub fn into_iter_sorted(self) -> IntoIterSorted<T, C>

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

pub fn peek_mut(&mut self) -> Option<PeekMut<'_, T, C>>

pub fn capacity(&self) -> usize

pub fn reserve(&mut self, additional: usize)

pub fn shrink_to_fit(&mut self)

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

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

pub fn into_vec(self) -> Vec<T>

pub fn into_sorted_vec(self) -> Vec<T>

pub fn sift_up(&mut self, start: usize, pos: usize) -> usize

pub fn sift_down_range(&mut self, pos: usize, end: usize)

Take an element at pos and move it down the heap, while its children are larger.

pub fn sift_down(&mut self, pos: usize)

pub fn sift_down_to_bottom(&mut self, pos: usize)

Take an element at pos and move it all the way down the heap, then sift it up to its position.

Note: This is faster when the element is known to be large / should be closer to the bottom.

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn drain(&mut self) -> Drain<'_, T>

pub fn clear(&mut self)

pub fn append(&mut self, other: &mut Self)

Trait Implementations

impl<T: Clone, C: Compare<T> + Clone> Clone for BinaryHeap<T, C>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, C: Compare<T>> Debug for BinaryHeap<T, C>

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

Formats the value using the given formatter.

impl<T: Ord> Default for BinaryHeap<T>

fn default() -> BinaryHeap<T>

Returns the “default value” for a type.

impl<'a, T: 'a + Copy, C: Compare<T>> Extend<&'a T> for BinaryHeap<T, C>

fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T, C: Compare<T>> Extend<T> for BinaryHeap<T, C>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T: Ord> From<Vec<T>> for BinaryHeap<T>

fn from(vec: Vec<T>) -> Self

creates a max heap from a vec

impl<T: Ord> FromIterator<T> for BinaryHeap<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<T, C: Compare<T>> Into<Vec<T>> for BinaryHeap<T, C>

fn into(self) -> Vec<T>

Converts this type into the (usually inferred) input type.

impl<'a, T, C: Compare<T>> IntoIterator for &'a BinaryHeap<T, C>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<T, C: Compare<T>> IntoIterator for BinaryHeap<T, C>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<T>

Creates an iterator from a value.