Stacks And Queues

栈和队列

大型填坑现场，第一部分的还没写，以上。

栈和队列是很基础的数据结构，前者后进先出，后者先进先出，如下图：

下面开始将客户端和具体实现分开，这样有两个好处：一是客户端不知道实现的细节，但同时也会有很多不同实现来选择；二是实现方面也不知道客户端需求的细节，但同时很多客户端可以也重用一样的实现。接口就像把二者连接起来的桥梁。

stacks

栈的操作主要是出栈入栈，热身来一个放字符串的栈。

stack API

栈的测试代码

public static void main(String[] args) {
    StackOfStrings stack = new StackOfString();
    while (!StdIn.isEmpty()) {
        String s = StdIn.readString();
        if (s.equals("-")) StdOut.print(stack.pop());
        else stack.push(s);
    }
}

stack linked-list

用链表来实现栈，出栈入栈示意：

代码：

public class LinkedStackOfStrings {
    private Node first = null;

    private class Node {
        String item;
        Node next;
    }

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

    public void push(String item) {
        Node oldfirst = first;
        first = new Node();
        first.item = item;
        first.next = oldfirst;
    }

    public String pop() {
        String item = first.item;
        first = first.next;
        return item;
    }
}

链表实现出入栈都只要常数的时间，一直都很快，相对的会需要较多额外的空间。参考 Analysis of Algorithms 最后的内存部分。

上面算的是每个栈节点需要的空间，不包括其中的字符串，字符串开销算在客户端上。

stack array

很常见的，能用链表实现，一般还有用数组实现的版本。

详细代码在下节的变长数组里，这里说下数组游离（loitering）问题。

出栈时把不要的元素置空，垃圾回收机制才能回收不用的内存。

resizing arrays

用数组来实现栈，在栈满的时候需要自动扩大数组容量，这样才符合前面设计的 API。具体即栈满时再创建一个容量更大的数组，然后把栈里原有的元素复制过去。

要是每次创建个容量加一的数组，往栈里加入前 N 个元素，光是每次复制元素就会是平方级别（1 + 2 + ... + N ~ \(N^{2}/2\)）。于是栈满的时候，我们直接把数组容量扩大两倍，这时往栈里加入前 N 个元素复制成本 2 + 4 + 8 + ... + N 和 N 成正比。

public ResizingArrayStackOfStrings() {
    s = new String[1];
}

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

private void resize(int capacity) {
    String[] copy = new String[capacity];
    for (int i = 0; i < N; i++) {
        copy[i] = s[i];
    }
    s = copy;
}

当栈里元素数目小于数组容量时，缩减数组长度可以节省空间，缩减操作是有必要的。一样的，每次缩减一格的代价太大，但是当栈里只剩一半元素时缩减到一半也会有问题。因为前面是栈满就扩大到两倍，如果在阈值处频繁地出入栈，就会频繁地扩大缩减还有复制来复制去。于是这里等栈里只剩四分之一的时候再缩减到一半，所以数组会一直处在 25% 到 100% 满之间。

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

数组实现的栈，在时间性能方面，因为可能有数组的扩大缩减，不能保证每次都很快，但是平摊下来，出入栈操作也能在常数时间内完成。在空间方面，会比用链表实现的栈好点：

栈里有 N 个元素时，使用空间介于 ~8N 和 ~32N 比特（栈 25%~100% 满），同样的没有算上存在客户端上字符串本身。参考 Analysis of Algorithms 最后的内存部分。

综合来看，链表实现的栈保证每个操作都很快，相对的需要多一点空间；数组实现的需要的空间少点，平摊下来出入栈也算是能在常数时间内完成。所以选择哪个实现，要看具体的应用需求，比如对操作时间要求很严格就选链表，等下关键时刻碰上数组扩大缩减；要是不需要保证每次都很快，那选数组会省空间。

queues

仍然，以一个放字符串的队列为例。

queue API

queue linked-list

链表实现的队列，出入队示意：

代码：

public class LinkedQueueOfStrings {
    private Node first, last;

    private class Node {
        String item;
        Node next;
    }

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

    public void enqueue(String item) {
        Node oldlast = last;
        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;
        return item;
    }
}

首尾两个节点在队列为空时要注意下。

queue array

数组实现不详述。

generics

上面我们实现了放字符串的栈和队列，要是现在需要放整数的呢，复制代码改下类型未免有点让人不太满意，泛型（generic）可以很好地解决这个问题。

把链表实现的栈改成上面那样，客户端就可以用这个栈存放任意类型的元素，只要你在声明时指定类型（Item）。另外，原始数据类型（short, int, long, float, double,, byte, boolean）需要借助对应的包装类，例如放整型的栈：Stack<Integer> s = new Stack<Integer>();。

但是有一个问题，Java 不允许创建泛型数组，所以数组实现的栈里面：

s = new Item[capacity];                // can't

s = (Item[]) new Object[capacity];    // ok

下面那行可行但编译时还是会有警告，不过也没什么关系。

关于 Java 不允许创建泛型数组，可以看看链接 1 和链接 2 的说明。其实我不是很懂，总觉得可以用泛型数组的话，也不会写成会有问题的例子那样。

iterators

对可迭代的（iterable）对象，Java 支持更优雅的 foreach 遍历。可迭代的对象含有一个返回迭代器（iterator）的方法，迭代器里又含有方法 hasNext() 和 next()（还有 remove()，课程不建议使用）。上面的栈变成下面这样，就可以用 foreach 来遍历。

linkes-list

import java.util.Iterator;

public class Stack<Item> implements Iterable<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 void remove() {
            /* not supported */
        }

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

array

import java.util.Iterator;

public class Stack<Item> implements Iterable<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 remove() {
            /* not supported */
        }

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

applications

课程建议我们在课程中不要使用 Java 里实现的栈和队列，除非你真的理解它们到底做了什么，因为商业实现的代码功能丰富，API 比较臃肿，未必像你想的那么有效率。

然后列了很多栈的应用，像网页回退，Word 中的撤销，编译器中的函数调用等等，特别介绍了算术表达式计算的双栈法。

• 操作数：压入操作数栈。
• 操作符：压入操作符栈。
• 左括号：忽略。
• 右括号：弹出两个操作数和一个操作符进行运算，结果再压入操作数栈。

代码：

public class Evaluate {
    public static void main(String[] args) {
        Stack<String> ops = new Stack<String>();
        Stack<Double> vals = new Stack<Double>();
        while (!StdIn.isEmpty()) {
            String s = StdIn.readString();
            if (s.equals("("))    ;
            else if (s.equals("+")) ops.push(s);
            else if (s.equals("-")) ops.push(s);
            else if (s.equals(")")) {
                String op = ops.pop();
                if (op.equals("+")) vals.push(vals.pop() + vals.pop());
                else if (op.equals("*")) vals.push(vals.pop() * vals.pop());
            }
            else vals.push(Double.parseDouble(s));
        }
        StdOut.println(vals.pop());
    }
}

这又是 Dijkstra 发明的方法，一步步从里到外把括号里的运算换成运算结果，最后即是整个算术表达式的结果。在此基础上，可以拓展到更多的其它运算，上面的例子只有加法和乘法，操作数可以交换，要是减法和除法的话，得把先 pop() 出的减（除）数储下来，再 pop() 出被减（除）数来减（除）去前者，不能像上面那么写。更有建立优先级矩阵，可以处理不带括号的表达式等。

另外，把上面表达式的操作符放操作数后面，变成 (1 ((2 3 +) (4 5 +)*)+)，Dijkstra 的双栈法也会算出同样的结果，而且这时式中的括号是冗余的，去掉也会得到正确的答案。原始的表达式操作符在操作数中间，称为中缀表达式，这里是它的后缀表达式或者叫逆波兰表示。