Stacks and Queues

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

推荐阅读更多精彩内容