使用链表实现堆栈

使用单向链表数据结构实现简易版的栈

栈结构是先进后出的结构，代码如下。

/**
 * 使用链表实现堆栈
 *
 */
public class Stack<E> implements Iterable<E> {

    private Node<E> firstNode;
    private int N;


    public boolean isEmpty(){
        return N==0;
    }

    public int size(){
        return N;
    }

    public void push(E item){
        Node<E> oldFirst = firstNode;
        firstNode = new Node<>();
        firstNode.next = oldFirst;
        firstNode.item = item;
        N++;
    }

    public E pop(){
        E item = firstNode.item;
        firstNode = firstNode.next;
        N--;
        return item;
    }

    public E peek() {
        if (isEmpty()) throw new NoSuchElementException("Stack underflow");
        return firstNode.item;
    }

    @Override
    public Iterator<E> iterator() {
        return new ListIterator();
    }


    private static class Node<E> {
        E item;
        Node<E> next;
        Node(){}
    }


    public static void main(String[] args) {
        Stack<String> s = new Stack<>();
        for (int i = 0 ; i < 6;i++){
            s.push(String.valueOf(i));
            System.out.println("size: " + s.size());
        }
        for (String per : s){
            System.out.println(per);
        }
    }

    private class ListIterator implements Iterator<E> {

        private Node<E> current = firstNode;

        @Override
        public boolean hasNext() {
            return current != null;
        }

        @Override
        public E next() {
            E item = current.item;
            current = current.next;
            return item;
        }

        @Override
        public void remove() {

        }
    }
}