Struct algorithms_rs::stack::Stack

pub struct Stack<T> { /* private fields */ }

stack data structure

在栈中，被删除的是最近插入的元素： 栈的实现是一种后进先出策略。 这里采用数组实现栈，还有别的方式也是可以实现栈的。

栈的操作

栈的操作有，栈上的INSERT操作称为压入PUSH,而无元素参数的DELETE操作称为弹出POP。

Implementations

impl<T: Clone> Stack<T>

pub fn new() -> Stack<T>

Creating an empty stack

use algorithms_rs::Stack;

let stack = Stack::<i32>::new();

assert_eq!(stack.is_empty(), true);

Examples found in repository

src/stack.rs (line 19)

    fn default() -> Self {
        Self::new()
    }

pub fn is_empty(&self) -> bool

Determine if stack is empty

use algorithms_rs::Stack;

let mut stack = Stack::<i32>::new();

assert_eq!(stack.is_empty(), true);

stack.push(2);

assert_eq!(stack.is_empty(), false);

STACK-EMPTY(S)
if S.top == 0
    return true
else return false

Examples found in repository

src/stack.rs (line 112)

    pub fn pop(&mut self) -> anyhow::Result<T> {
        if self.is_empty() {
            Err(anyhow::anyhow!("underflow"))
        } else {
            self.top -= 1;
            Ok(self.data.remove(self.top))
        }
    }

    /// Return the top element of the stack
    ///
    /// ```rust
    /// use algorithms_rs::Stack;
    ///
    /// let mut stack = Stack::<i32>::new();
    ///
    /// assert_eq!(stack.peek(), None);
    ///
    /// stack.push(1);
    /// stack.push(2);
    ///
    /// assert_eq!(stack.peek(), Some(&2));
    /// assert_eq!(stack.is_empty(), false);
    /// ```
    pub fn peek(&self) -> Option<&T> {
        if self.is_empty() {
            return None;
        }
        self.data.get(self.top - 1)
    }

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

Put an element into the top of the stack of stack

use algorithms_rs::Stack;

let mut stack = Stack::<i32>::new();

stack.push(1);

assert_eq!(stack.is_empty(), false);

PUSH(S, x)
    S.top = S.top + 1
    S[S.top] = x

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

Remove an element from the top of the stack of stack

use algorithms_rs::Stack;

let mut stack = Stack::<i32>::new();

stack.push(1);

let element = stack.pop().unwrap();

assert_eq!(element, 1);
assert_eq!(stack.is_empty(), true);

if let Err(err) = stack.pop() {
 assert_eq!(err.to_string(), "underflow".to_string())
}

POP(S)
    if STACK-EMPTY(S)
        error "underflow"
    else
        S.top = S.top - 1
        return S[S.top + 1]

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

Return the top element of the stack

use algorithms_rs::Stack;

let mut stack = Stack::<i32>::new();

assert_eq!(stack.peek(), None);

stack.push(1);
stack.push(2);

assert_eq!(stack.peek(), Some(&2));
assert_eq!(stack.is_empty(), false);

pub fn size(&self) -> usize

the stack size

use algorithms_rs::Stack;

let stack = Stack::<i32>::new();

assert_eq!(0, stack.size());

Trait Implementations

impl<T: Debug> Debug for Stack<T>

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

Formats the value using the given formatter.

impl<T: Clone> Default for Stack<T>

fn default() -> Self

Returns the “default value” for a type.