Struct 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);

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

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.