Struct stdlib_rs::collections::min_stack::MinStack

pub struct MinStack<T: Ord>(_);

A Stack data type that supports accessing the minimum item in the stack in O(1) time.

Implementations

impl<T> MinStack<T> where
    T: Clone + Ord + Default, 

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

Moves all the elements of other into Self, leaving other empty.

Panics

Panics if the number of elements in the MinStack overflows a usize.

Examples

let mut left = min_stack![1];
let mut right = min_stack![2];
left.append(&mut right);
assert_eq!(left, min_stack![1, 2]);

impl<T> MinStack<T> where
    T: Clone + Ord, 

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

Finds the minimum item of the stack in O(1) time. If the stack is empty, returns None.

Examples

let stack = min_stack![1, 2];
let empty: MinStack<i32> = min_stack![];
assert_eq!(stack.min(), Some(1));
assert_eq!(empty.min(), None);

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

Look at the top item of the stack in O(1) time. If the stack is empty, returns None.

Examples

let stack = min_stack![1, 2];
let empty: MinStack<i32> = min_stack![];
assert_eq!(stack.peek(), Some(2));
assert_eq!(empty.peek(), None);

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

Adds an item to the end of the stack in O(1) time.

Examples

let mut stack = min_stack![1];
stack.push(2);
assert_eq!(stack.len(), 2);

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

Creates a min_stack from a vector.

Examples

let v = vec![1, 2, 3];
let stack: MinStack<i32> = MinStack::from(v);
assert_eq!(stack, min_stack![1, 2, 3]);

impl<T> MinStack<T> where
    T: Ord, 

pub fn new() -> Self

Creates a new MinStack.

pub fn as_slice(&self) -> &[(T, T)]

Extracts a slice containing the Min Stack. Equivalent to &s[..].

pub fn as_ptr(&self) -> *const (T, T)

Returns a raw pointer to the min_stack.

pub fn as_mut_ptr(&mut self) -> *mut (T, T)

Returns a mutable pointer to the min_stack.

pub fn clear(&mut self)

Clears the MinStack, removing all values.

Examples

let mut stack = min_stack![1,2,3];
stack.clear();
assert_eq!(stack, min_stack![]);

pub fn with_capacity(capacity: usize) -> MinStack<T>

Creates a new MinStack with the given capacity.

Examples

let stack: MinStack<i32> = MinStack::with_capacity(10);
assert!(stack.capacity() >= 10);

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

Reserves capacity for at least additional more elements to be inserted in the given MinStack<T>. The collection may reserve more space to avoid frequent reallocations. After calling reserve, capacity will be greater than or equal to self.len() + additional. Does nothing if capacity is already sufficient.

Examples

let mut stack = min_stack![1];
stack.reserve(10);
assert!(stack.capacity() >= 11);

pub fn capacity(&self) -> usize

Returns the number of elements the vector can hold without reallocating.

Examples

let stack: MinStack<i32> = MinStack::with_capacity(10);
assert!(stack.capacity() >= 10);

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

Removes the last element from a vector and returns it, or None if it is empty.

Examples

let mut stack = min_stack![1, 2, 3];
let mut empty: MinStack<i32> = min_stack![];
assert_eq!(stack.pop(), Some(3));
assert_eq!(empty.pop(), None);

pub fn is_empty(&self) -> bool

Returns true if the MinStack has no elements.

Examples

let stack = min_stack![1, 2, 3];
let empty: MinStack<i32> = min_stack![];
assert_eq!(stack.is_empty(), false);
assert_eq!(empty.is_empty(), true);

pub fn len(&self) -> usize

Returns the number of elements in the stack.

Examples

let stack = min_stack![1, 2, 3];
assert_eq!(stack.len(), 3);

Trait Implementations

impl<T: Clone + Ord> Clone for MinStack<T>

fn clone(&self) -> MinStack<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Ord> Debug for MinStack<T>

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

Formats the value using the given formatter.

impl<T: Default + Ord> Default for MinStack<T>

fn default() -> MinStack<T>

Returns the “default value” for a type.

impl<T> Deref for MinStack<T> where
    T: Ord, 

type Target = [(T, T)]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for MinStack<T> where
    T: Ord, 

fn deref_mut(&mut self) -> &mut [(T, T)]

Mutably dereferences the value.

impl<T> Index<usize> for MinStack<T> where
    T: Ord, 

type Output = (T, T)

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IntoIterator for MinStack<T> where
    T: Ord, 

type Item = (T, T)

The type of the elements being iterated over.

type IntoIter = IntoIter<Self::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq + Ord> PartialEq<MinStack<T>> for MinStack<T>

fn eq(&self, other: &MinStack<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &MinStack<T>) -> bool

This method tests for !=.

impl<T: PartialOrd + Ord> PartialOrd<MinStack<T>> for MinStack<T>

fn partial_cmp(&self, other: &MinStack<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Eq + Ord> Eq for MinStack<T>

impl<T: Ord> StructuralEq for MinStack<T>

impl<T: Ord> StructuralPartialEq for MinStack<T>