Java 用链表实现栈和队列

栈

　　是一种基于后进先出(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;
    }

}