[数据结构与算法]栈Stack的多种实现

package stack;

/**
 * 栈接口
 * @author jzj
 *
 * @param <E>
 */
public interface Stack<E> {
    //入栈
    public void push(E e);

    //出栈
    public E pop();

    //取栈顶元素
    public E peek();

    //当前栈大小
    public int size();

    //栈是否为空
    public boolean isEmpty();
}

package stack;

/**
 * 使用 单链表 实现栈
 * @author jzj
 *
 * @param <E>
 */
public class LinkedStack<E> implements Stack<E> {
    private class Node {
        E data;//数据域
        Node next;//next域

        Node() {//栈底元素构造函数
            data = null;
            next = null;
        }

        /**
         * 非栈底元素构造函数
         * @param data 数据域
         * @param next 新建节点next域指向
         */
        Node(E data, Node next) {
            this.data = data;
            this.next = next;
        }

        //是否到栈底元素
        boolean isEnd() {
            return data == null && next == null;
        }
    }

    /*
     * 栈顶元素，刚开始时创建一个data与next域都为null的节点，它是一个标志性节点，
     * 也相当于栈底，如判断栈是否为空就可以使用它：如果top指向了这个节点，就表明已
     * 到栈底了，即栈为空
     */
    private Node top = new Node();

    //入栈
    public void push(E data) {
        //让栈顶指向新建节点
        top = new Node(data, top);
    }

    //出栈
    public E pop() {
        //该节点可能是栈底元素，如果是则返回为null
        E data = top.data;
        if (!top.isEnd()) {//如果不是栈底，则指向下一个元素
            top = top.next;
        }
        return data;
    }

    //取栈顶元素
    public E peek() {
        //该节点可能是栈底元素，如果是则返回为null
        return top.data;
    }

    //栈大小
    public int size() {
        int size = 0;
        Node tmpTop = top;
        while (tmpTop.next != null) {
            size++;
            tmpTop = tmpTop.next;
        }
        return size;
    }

    //栈是否为空
    public boolean isEmpty() {
        return top.isEnd();
    }
}

package stack;

import java.util.LinkedList;

/**
 * 使用 LinkedList 实现栈
 * @author jzj
 *
 * @param <E>
 */
public class LinkedListStack<E> implements Stack<E> {
    private LinkedList<E> list = new LinkedList<E>();

    //入栈
    public void push(E e) {
        list.addFirst(e);
    }

    //出栈
    public E pop() {
        return list.removeFirst();
    }

    //取栈顶元素
    public E peek() {
        return list.getFirst();
    }

    //当前栈大小
    public int size() {
        return list.size();
    }

    //栈是否为空
    public boolean isEmpty() {
        return list.isEmpty();
    }
}

package stack;

/**
 * 使用 数组 实现栈
 * @author jzj
 *
 * @param <E>
 */
public class ArrayStack<E> implements Stack<E> {
    private E[] data;
    private int top = -1;//指向栈顶元素
    private int size = 3;

    public ArrayStack() {
        data = (E[]) new Object[size];
    }

    //入栈
    public void push(E e) {
        if ((top + 1) == size) {
            throw new IllegalStateException("stack full...");
        }
        data[++top] = e;
    }

    //出栈
    public E pop() {
        if (top == -1) {
            throw new IllegalStateException("stack empty...");
        }
        E tmp = data[top];
        //用完后释放对象，加快垃圾回收，防止大的对象不用发生内存泄露
        data[top] = null;
        top--;
        return tmp;
    }

    //取栈顶元素
    public E peek() {
        if (top == -1) {
            throw new IllegalStateException("stack empty...");
        }
        return data[top];
    }

    //当前栈大小
    public int size() {
        return top + 1;
    }

    //栈是否为空
    public boolean isEmpty() {
        return top == -1;
    }
}

package stack;

import java.util.ArrayList;

/**
 * 使用 ArrayList 实现栈
 * @author jzj
 *
 * @param <E>
 */
public class ArrayListStack<E> implements Stack<E> {
    private ArrayList<E> list = new ArrayList<E>();

    //入栈
    public void push(E e) {
        list.add(e);//ArrayList默认就是在数组尾加入元素，从后面进
    }

    //出栈
    public E pop() {
        return list.remove(list.size() - 1);//从前面出
    }

    //取栈顶元素
    public E peek() {
        return list.get(list.size() - 1);
    }

    //当前栈大小
    public int size() {
        return list.size();
    }

    //栈是否为空
    public boolean isEmpty() {
        return list.isEmpty();
    }
}