[数据结构与算法]栈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();
     }
 }