栈

　　是一种基于后进先出(LIFO)策略的集合类型。当邮件在桌上放成一叠时，就能用栈来表示。新邮件会放在最上面，当你要看邮件时，会一封一封从上到下阅读。栈的顶部称为栈顶，所有操作都在栈顶完成。

　　前面提到的新邮件，就是在栈顶入栈（push），阅读的时候从栈顶取出一封就是出栈（pop）。就像下面这个图一样，你不能从最下面直接拿一封信出来。

 package ABAB; /**
  * 链表实现栈
  * @param <Item>
  */
 public class Stack<Item> {     private Node first;
     private Integer N = 0;     private class Node {
         Item item;
         Node next;         public Node(Item i) {
             this.item = i;
             this.next = null;
         }
     }     public boolean isEmpty() { return N == 0; }     public int size() { return N; }     /**
      * 进栈
      *
      * @param i
      */
     public void push(Item i) {
         Node node = new Node(i);
         if (first == null) {
             first = node;
             N++;
             return;
         }
         Node oldFirst = first;
         first = node;
         first.next = oldFirst;
         N++;
     }     /**
      * 获取栈顶元素
      *
      * @return
      */
     public Item peek() {
         if (first == null)
             return null;
         return first.item;
     }     /**
      * 出栈
      *
      * @return
      */
     public Item pop() {
         if (isEmpty())
             return null;
         Item item = first.item;
         first = first.next;
         N--;
         return item;
     } }

队列

　　队列是一种基于先进先出（FIFO）策略的集合类型。例如排队上车，先排队的人可以先上车。

　　队列的链表实现中有两个指针，一个指向队头，一个指向队尾。当有新的元素进入时，新元素被放在队尾。当要出队时，从队头弹出元素，并且将队头后移。

 package ABAB; /**
  * 链表实现队列
  * @param <Item>
  */
 public class Queue<Item> {     private Node first;
     private Node last;
     private int N = 0;
     private class Node{
         Item item;
         Node next;
         public Node(Item i){
             this.item = i;
             this.next = null;
         }
     }     public boolean isEmpty(){return N == 0;};
     public int size(){return N;}     /**
      * 入队
      * @param item
      */
     public void enqueue(Item item){
         Node node = new Node(item);
         Node oldLast = last;
         last = node;
         if(isEmpty())
             first = last;
         else
             oldLast.next = last;
         N++;
     }     /**
      * 出队
      * @return
      */
     public Item dequeue(){
         Item item;
         if(isEmpty())
             return null;
         item = first.item;
         first = first.next;
         N--;
         return item;
     }     /**
      * 获取队首元素
      * @return
      */
     public Item peek(){
         if(isEmpty())
             return null;
         return first.item;
     } }