实现栈的两种方式--数组链表

方式一：数组实现

代码：

public class ArrayStack {
    private Object[] stack;
    private int size;//存储元素的个数

    public ArrayStack() {
        stack = new Object[2];
    }

    //判断栈是否为空
    public boolean isEmpty(){
        return size==0;
    }

    //栈顶查看数据
    public Object peek(){
        if (isEmpty()){
            return null;
        }
        return stack[size-1];
    }

    //从栈顶取出元素
    public Object pop(){
        Object o = peek();
        size--;
        stack[size] = null;
        return o;
    }

    //判断栈是否到达了最大容量
    private void ensureCapacity(int size){
        int length = stack.length;
        if (size > length){
            int newLen = 2;//栈每次扩充的数组长度
            stack = Arrays.copyOf(stack, newLen+length);
        }
    }

    //栈中存入元素
    public void push(Object o){
        ensureCapacity(size+1);
        stack[size++] = o;
    }

    public static void main(String[] args) {
        ArrayStack stack = new ArrayStack();
        stack.push(1);
        stack.push(1);
        stack.push(1);
        stack.push(1);

    }
}

链表实现

相信大家在之前实现栈都是使用数组实现的，当然在JDK中Stack是继承自Vector，底层实现也是数组，但是数组实现存在着扩容的问题。

代码：

public class LinkStack<E> {
    Node<E> top = null;
    public boolean isEmpty(){
        return top == null;
    }
    //插入元素
    public void push(E e){
        Node<E> newNode = new Node<E>(e);
        newNode.next = top;
        top = newNode;
    }
    //弹出
    public E pop(){
        if (isEmpty()){
            return null;
        }
        E data = top.data;
        top = top.next;
        return data;
    }
    //查看栈顶元素
    public E peek(){
        if (isEmpty()){
            return null;
        }
        return top.data;
    }
}

class Node<E>{
    Node<E> next = null;
    E data;
    public Node(E data){
        this.data = data;
    }
}