java实现栈结构

java实现栈结构

抽取栈的通用方法

public interface Stack<E> {

    /**
     * 向栈中插入数据
     * @param element 数据
     */
    void push (E element);

    /**
     * 弹栈
     * @return 栈顶元素
     */
    E pop ();

    /**
     * 查看栈顶元素
     * @return 栈顶元素
     */
    E peek();
}

数组实现栈

public class ArrayStack<E> implements Stack<E> {
    private Object[] elements;
    private int size;
    private static final int DEFAULT_CAPACITY = 10;

    public ArrayStack() {
        elements = new Object[DEFAULT_CAPACITY];
        size = 0;
    }

    @Override
    public void push(E item) {
        ensureCapacity();
        elements[size++] = item;
    }

    @Override
    public E pop() {
        if (size == 0) {
            throw new RuntimeException("栈内数据为空");
        }
        E item = (E) elements[--size];
        elements[size] = null;
        return item;
    }

    @Override
    public E peek() {
        if (size == 0) {
            throw new RuntimeException("栈内数据为空");
        }
        E item = (E) elements[--size];
        size++;
        return item;
    }

    private void ensureCapacity() {
        if (size == elements.length) {
            int newSize = size * 2;
            Object[] newElements = new Object[newSize];
            System.arraycopy(elements,0,newElements,0,elements.length);
            elements = newElements;
        }
    }
}

链表实现栈

public class LinkedListStack<E> implements Stack<E> {

    private Node<E> head;

    private Node<E> tail;

    private int size;

    public LinkedListStack() {
        head = null;
        tail = null;
        size = 0;
    }

    public static class Node<E> {
        private E item;
        private Node<E> prev;
        private Node<E> next;

        public E getItem() {
            return item;
        }

        public void setItem(E item) {
            this.item = item;
        }

        public Node<E> getPrev() {
            return prev;
        }

        public void setPrev(Node<E> prev) {
            this.prev = prev;
        }

        public Node<E> getNext() {
            return next;
        }

        public void setNext(Node<E> next) {
            this.next = next;
        }
    }

    @Override
    public void push(E element) {
        Node<E> eNode = new Node<>();
        eNode.setItem(element);
        if (head == tail && head == null) {
            head = tail = eNode;
            size++;
        } else {
            tail.setNext(eNode);
            eNode.setPrev(tail);
            tail = eNode;
            size++;
        }
    }

    @Override
    public E pop() {

        if (isEmpty()) {
            throw new RuntimeException("栈为空");
        }
        E item = tail.getItem();

        tail = tail.getPrev();
        tail.setNext(null);
        size--;
        return item;
    }

    private boolean isEmpty() {
        return size == 0;
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            throw new RuntimeException("栈为空");
        }
        return tail.getItem();
    }
}

测试类

public class Client {
    public static void main(String[] args) {
        LinkedListStack<Integer> linkedListStack = new LinkedListStack<>();
        linkedListStack.push(1);
        linkedListStack.push(2);
        linkedListStack.push(3);
        System.out.println(linkedListStack.pop());
        System.out.println(linkedListStack.peek());
        System.out.println(linkedListStack.pop());
    }
}