stack：last in first out (LIFO)
queue: first in fist out (FIFO)

stack API

• linked-list stack implementation

public class LinkedStackofStrings{
    private Node first = null;
    private class Node(){
        String item;
        Node next;
    }

    //insert a new string into stack
    public void push(String item){
        //在链表的头结点入栈
        Node oldfirst = first;
        first = new Node();
        first.item = item;
        first.next = oldfirst;
    }
    
    //remove and return the string most recently added
    public String pop(){
        String item = first.item;
        first = first.next;
        return item;
    }
    
    //is the stack empty?
    public boolean isEmpty(){
        return first==null;
    }
}

• array stack implementation
  s[N]为栈顶，为空

public class FixedCapacityStackofStrings{
    private String[] s;
    private int N = 0;
    //固定大小的栈
    public FixedCapacityStackofStrings(int capacity){
        s = new String[capacity];
    }
    //insert a new string into stack
    public void push(String item){
        s[N++] =item; 
    }
    
    //remove and return the string most recently added
    public String pop(){
        return s[--N]; 
    }
    
    //is the stack empty?
    public boolean isEmpty(){
        return N == 0;
    }
}

问题：
1.underflow：从空栈pop时
2.overflow：向已满的栈push时；解决方法为resize数组大小
3.空item：解决方法为允许null入栈
4.loitering（内存泄漏？）：当pop时，依然有指向object的指针；更改为：

public String pop(){
    String item = s[--N];
    s[N] == null;
    return item;
}

resizing array

但是上述数组的实现需要用户提供栈的固定容量，但一般没有人能确定栈的最大容量，因此最好能随时增大数组。

• first try

push：array size加一；
pop：array size减一；

too expensive,每次改变数组大小时都要把所有项复制到新数组中，因此插入N项的时间复杂度为1+2+3+4+……+N，约为N的平方。

因此最好保证resize array不那么频繁。

• 改进

如果数组满了，则将数组的大小变为原来的二倍。

public ResizingArrayStackofStrings{
    private s = new String[1];
    public void push(String item){
        if(N==s.length) resize(2*s.length);
        s[N++] = item;
    }

    public void resize(int capacity){
        String[] copy = new Stirng[2*capacity];
        for(int i = 0;i<s.length;i++){
            copy[i] = s[i];
        }
        s = copy;
    }
}

此时插入N项所需的时间复杂度为2+4+8+……+N，即每次复制的item个数为2的k次方，则1+2+4+8+……+2的k次方为2的k+1次方，即2N（N为2的k次方），因此时间复杂度为N，相比每插入一项就增大数组size的N平方有了很大改进。

那缩小数组呢？

• first try

当数组内容变为原来的一半时将数组缩小至原来的一半。
但当数组满的时候，push会加倍数组的长度，pop又会减半数组的长度，就这么交替地push、pop、push、pop，每次操作时间复杂度都为N

• efficient solution

当数组1/4满时，将数组长度减半.

public String pop(){
    String item = s[--N];
    s[N] = null;
    if(N>0 && N == s.length/4) resize(s.length/2);
    return item;
}

这样array的长度是在25%到100%之间。

因此，resizing arrays的push和pop时间复杂度都为O(N)。

Queue API

• linked-list implementation

public class LinkedListQueueofStrings{
    private class Node{
        String item;
        Node next;
    }
    public void enqueue(String item){
        Node oldlast = last;
        Node last = new Node();
        last.item = item;
        last.next = null;
        if(isEmpty()) first = last;
        else  oldlast.next = last;
    }

    public String dequeue(){
        String item = first.item;
        first = first.next;
        if(isEmpty()) last = null;
    }

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

• resizing arrays