Struct BoundedBinaryHeaper

pub struct BoundedBinaryHeaper<'a, T: 'a> { /* private fields */ }

Heaper converts underlying slice into a binary heap with bound

Implementations

impl<'a, T: 'a + PartialOrd> BoundedBinaryHeaper<'a, T>

pub fn from(slice: &'a mut [T]) -> BoundedBinaryHeaper<'a, T>

Create a new BoundedBinaryHeaper on top of a slice

extern crate rust_heap;
use rust_heap::heap::BoundedBinaryHeaper;
let mut v=[5,4,3,2,1];
let mut h = BoundedBinaryHeaper::from(&mut v);
assert_eq!(h.capacity(), 5);
assert_eq!(h.len(), 5);

pub fn from_empty_slice(slice: &'a mut [T]) -> BoundedBinaryHeaper<'a, T>

Create a new BoundedBinaryHeaper on top of an slice and ignore all contents in it

extern crate rust_heap;
use rust_heap::heap::BoundedBinaryHeaper;
let mut v=[5,4,3,2,1];
let mut h = BoundedBinaryHeaper::from_empty_slice(&mut v);
assert_eq!(h.capacity(), 5);
assert_eq!(h.len(), 0);

pub fn push(&mut self, elem: T) -> Option<T>

Push a value into heap if value>=root and keep heap structure Overflow and return the smallest element when heap is full

extern crate rust_heap;
use rust_heap::heap::BoundedBinaryHeaper;
let mut v=[3,2,1];
let mut h = BoundedBinaryHeaper::from(&mut v);
assert_eq!(h.push(4).unwrap(), 1);
assert_eq!(h.len(), 3);

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

Pop the smallest value from heap

extern crate rust_heap;
use rust_heap::heap::BoundedBinaryHeaper;
let mut v=[3,2,1];
let mut h = BoundedBinaryHeaper::from(&mut v);
assert_eq!(*h.pop().unwrap(), 1);

pub fn len(&self) -> usize

Return the number of elements in the heap

pub fn is_empty(&self) -> bool

Return true if the heap is empty

pub fn capacity(&self) -> usize

Return the number of elements the heap can store

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

Return the smallest element or None if the heap is empty