栈的两种实现方式

1.数组实现

/**
 * @author yhd
 * @email 
 * @description 栈 ，使用数组实现 ， 基本操作包括 入栈 出栈 栈中元素个数
 * @since 2021/4/7 0:21
 */
public class Zhan<T> {
    //栈容器
    private T[] arr;

    //构造器指定栈容量
    public Zhan(int size) {
        arr = (T[]) new Object[size];
    }

    //记录栈中元素个数
    private int length = 0;

    //入栈
    public void push(T data) {
        if (length + 1 <= arr.length) {
            arr[length++] = data;
        }else{
            throw new RuntimeException("栈满，无法添加元素");
        }
    }

    //出栈
    public T pop() {
        if (length == 0) {
            throw new RuntimeException("栈空，无元素可以弹出！");
        }
        T data = arr[--length];
        arr[length] = null;
        return data;
    }

    public int getSize() {
        return length;
    }
}

2.链表实现

/**
 * @author yhd
 * @email yinhuidong1@xiaomi.com
 * @description 使用链表实现栈  入栈 出栈 栈中元素个数
 * @since 2021/4/7 1:03
 * <p>
 * 1
 * 2 1
 * 3 2 1
 * 4 3 2 1
 * 5 4 3 2 1
 * 5 4 3 2
 * 5 4 3
 * 5 4
 * 5
 */
public class Zhan2 {

    LinkList linkList;

    public Zhan2(){
     linkList=new LinkList();
    }

    //入栈
    public void push(int data){
        linkList.push(data);
    }

    //出栈
    public int pop(){
        return linkList.pop();
    }

    //元素个数
    public int size(){
        return linkList.getLength();
    }
    class Node {
        int data;
        Node next;

        public Node(int data) {
            this.data = data;
        }
    }

    class LinkList {
        Node head = new Node(0);

        int length = 0;

        //入栈 头插
        public void push(int data) {
            if (head.next == null) {
                head.next = new Node(data);
            } else {
                Node node = new Node(data);
                node.next = head.next;
                head.next = node;
            }
            length++;
        }

        //出栈 头删
        public int pop() {
            if (head.next == null) {
                throw new RuntimeException("栈中无元素，无法弹出！");
            }
            int data = head.next.data;
            head.next=head.next.next;
            length--;
            return data;
        }

        //元素个数
        public int getLength() {
            return length;
        }
    }
}