栈

栈是一种基于后进先出的数据集合。用链表实现比数组实现更加高效。

使用链表以及泛型机制来实现可以达到最优设计目标：

　　（1）可以处理任意类型的数据；

　　（2）所需的空间总是和集合的大小成正比；

　　（3）操作所需的时间总是和集合的大小无关。

××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××

数组实现代码：

import java.util.Iterator;
import java.util.Scanner;

public class ResizingArrayStack<Item> implements Iterable<Item> {
    
    private Item[] a = (Item[]) new Object[1];        //item
    private int n = 0;                                //size

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

    public int size(){
        return n;
    }

    private void resize(int max){
        //new Item[max]
        Item[] tmp = (Item[]) new Object[max];
        for(int i = 0; i < n; i ++){
            tmp[i] = a[i];
        }
        a = tmp;
    }

    public void push(Item item){
        if(n == a.length){
            //full
            resize(n * 2);
        }
        a[n ++] = item;
    }

    public Item pop(){
        Item item = a[-- n];
        a[n] = null;            //avoid loitering

        if(n > 0 && n == a.length / 4){
            //too large
            resize(a.length / 2);
        }

        return item;
    }

    public Iterator<Item> iterator(){
        return new ReverseArrayIterator();
    }

    private class ReverseArrayIterator implements Iterator<Item> {

        private int i = n;
        
        public boolean hasNext(){
            return i > 0;
        }

        public Item next(){
            return a[-- i];
        }

        public void remove(){}
        
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        ResizingArrayStack<String> s = new ResizingArrayStack<>();
        while(in.hasNext()){
            String item = in.next();
            if(!item.equals("-")){
                s.push(item);
            }
            else if(!s.isEmpty()){
                System.out.print(s.pop() + " ");
            }
        }

        System.out.println("(" + s.size() + " left on stack)");
    }
}

链表实现代码：

import java.util.Scanner;
import java.util.Iterator;

public class Stack<Item> implements Iterable<Item>{

    private class Node{
        //LinkedList Node
        Item item = null;
        Node next = null;
    }

    private Node first = null;        //top
    private int n = 0;                //size

    public boolean isEmpty(){
        return first == null;
    }

    public int size(){
        return n;
    }

    public void push(Item item){
        Node oldFirst = first;
        first = new Node();
        first.item = item;
        first.next = oldFirst;
        n ++;
    }

    public Item pop(){
        Item item = first.item;
        first = first.next;
        n --;
        return item;
    }

    public Iterator<Item> iterator(){
        return new ListIterator();
    }

    private class ListIterator implements Iterator<Item>{
        private Node current = first;

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

        public Item next(){
            Item item = current.item;
            current = current.next;
            return item;
        }

        public void remove(){}
    }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        Stack<String> s = new Stack<>();
        while(in.hasNext()){
            String item = in.next();
            if(!item.equals("-")){
                s.push(item);
            }
            else if(!s.isEmpty()){
                System.out.print(s.pop() + " ");
            }
        }

        System.out.println("(" + s.size() + " left on stack)");
    }
}

 （参考自《Algorithm 4th》）