栈的两种基本实现

实现栈的两种方式（Java）

1使用数组实现栈

/**
 * @Version: 1.0
 * @Author: alice
 * @Date: 2021/11/29
 * @Content: 栈的数组实现方式
 */
public class ArrayStack<E> {
    /**
     * 数组存放元素
     */
    Object[] stack;

    /**
     * 栈顶
     */
    int top;

    /**
     * 指定个数的初始化
     * @param maxsize
     */
    public ArrayStack(int maxsize){
        top = -1;
        stack = new Object[maxsize];
    }

    /**
     * 不指定个数的初始化
     */
    public ArrayStack(){
        top = -1;
        stack = new Object[10];
    }

    /**
     * 判断栈是否满
     * @return
     */
    public boolean isFull(){
        return top == stack.length - 1;
    }

    /**
     * 栈是否为空
     * @return true or false
     */
    public boolean isEmpty(){
        return top == -1;
    }

    /**
     * 入栈
     * @param e 传入的元素
     */
    public void push(E e){
        //扩容
        if (isFull()){
            stack = Arrays.copyOf(stack,stack.length*2);
        }
        stack[++top] = e;
    }

    /**
     * 返回栈顶元素
     * @return
     */
    public E topStack(){
        if (isEmpty()){
            return null;
        }
        return (E) stack[top];
    }

    /**
     * 出栈
     * @return
     */
    public E pop(){
        if (isEmpty()){
            return null;
        }
        return (E) stack[top--];
    }

    /**
     * 元素的个数
     * @return
     */
    public int size(){
        if (top == -1){
            return -1;
        }
        int count = 0;
        for (int i = 0; i < stack.length; i++) {
            if (stack[i] != null){
                count++;
            }
        }
        return count;
    }

    /**
     * 遍历栈
     */
    public void show(){
        if (isEmpty()){
            System.out.println("====栈空，无数据====");
            return;
        }
        for (int i = top; i >= 0; i--) {
            System.out.println("stack["+i+"]"+stack[i]);
        }
    }

2.使用链表实现栈

**
 * @Version: 1.0
 * @Author: alice
 * @Date: 2021/11/30
 * @Content:    用链表实现栈
 */
public class LinkedStack<T> {

    /**
     * 链表的头结点，即栈顶
     */
    private StackNode<T> top = null;


    public boolean isEmpty(){
        return top == null;
    }

    /**
     * 入栈
     * @param val
     */
    public void push(T val){
        StackNode<T> node = new StackNode<>(val);
        node.next = top;
        top = node;
    }

    /**
     * 出栈
     * @return
     */
    public T pop(){
        if (isEmpty()){
            return null;
        }
        T data = top.data;
        top = top.next;
        return data;
    }

    /**
     * 返回栈顶元素
     * @return
     */
    public T reHead(){
        if (isEmpty()){
            return null;
        }
        return top.data;
    }
    
   class StackNode<T> {
       T data;
           
       StackNode<T> next;
       
       public StackNode(T data) {
        this.data = data;
    }

       public StackNode(){};
    }

    
}