Symbol Tables

符号表

符号表是键值对的集合，支持给定键查找值的操作，有很多应用：

API

put() 和 get() 是最基础的两个操作，为了保证代码的一致性，简洁性和实用性，先说下具体实现中的几个设计选择。

• 泛型 我们在考虑方法时不指定在处理的键和值的类型，而是使用泛型。

• 重复的键 每个键只对应一个值（表里没有重复的键），插入键值对的时候如果发现表里已经有这个键，那就更新该键值对的值。这些约定定义了关联数组（associative array）抽象，你可以把符号表想象成一个数组，其中键是索引而值是数组元素。

• 空值 不允许键对应的值为空（null）。直接原因是 get() 方法在表里没有相应传入的键时返回 null。这样约定，给定键我们还可以看符号表是否给它定义了值，看 get() 方法是否返回 null 就好。另外，方法 delete() 可以通过调用 put() 方法时在第二个参数传 null 来实现。

• 删除 符号表的删除操作一般有两种策略。一是懒删除（lazy deletion），即上面提到的直接用 put() 更新为 null，然后可能过会儿再移除这样的键。二是即时删除（eage deletion），马上把键从符号表中移除。在我们的符号表实现中不会使用默认方案，即不用 put(key, null)。

• 迭代 key() 返回一个迭代器给客户端遍历所有键。

• 键的等价性 Java 要求为每个对象实现一个 equals() 方法，本身也为标准类型如 Integer，Double 和 String 以及更复杂的类型如 Date，File 和 URL 实现了这个方法，我们以这个方法来确定一个给定的键是否在符号表中。在实际中，对自定义的键需要重写 equals() 方法，这在 part1-pa4 中有提过，可以参考 Date.java 和 Transaction.java，提下原来没讲到的 equals() 应实现一个等价关系，满足:

  • 自反性（Reflexive）：x.equals(x) 返回真。

  • 对称性（Symmetric）：若 x.equals(y) 为真，则 y.equals(x) 也为真。

  • 传递性（Transitive）：若 x.equals(y) 为真且 y.equals(z) 为真，那么 x.equals(z) 为真。

另外，equals() 的参数必须是一个对象，还要满足：

• 一致性（Consistency）：当两个对象都没有被修改时，多次调用 x.equals() 返回相同的值。

• 非空：x.equals(null) 返回 false。

最后，最好使用不可变的数据类型作为键，以此来保证符号表的一致性。

再蛮打一下符号表的测试用例，一个统计字符最近出现的位置，一个输出出现频率最高的字符串：

public static void main(String[] args) {
    ST<String, Integer> st = new ST<String, Integer>();
    for (int i = 0; !StdIn.isEmpty(); i++) {
        String key = StdIn.readString();
        st.put(key, i);
    }

    for (String s : st.keys()) {
        StdOut.println(s + " " + st.get(s));
    }
}

public class FrequencyCounter {
    public static void main(String[] args) {
        int minlen = Integer.parseInt(args[0]);
        ST<String, Integer> st = new ST<String, Integer>();
        while (!StdIn.isEmpty()) {
            String word = StdIn.readString();
            if (word.length() < minlen) continue;    // ignore short strings
            if (!st.contains(word)) st.put(word, 1);
            else st.put(word, st.get(word) + 1);
        }

        String max = "";
        st.put(max, 0);
        for (String word : st.keys()) {
            if (st.get(word) > st.get(max))
                max = word;
        }
        StdOut.println(max + " " + st.get(max));
    }
}

elementary implementations

符号表的一个简单实现是使用链表（无序），每个节点存储一个键值对。get() 方法遍历链表，用 equals() 方法匹配查找的键，成功则返回对应的值，失败则返回 null。put() 方法同样遍历链表，用 equals() 方法看表中是否已存在该键，存在则更新对应的值，不存在则新生成一个节点存在表头。这种方法，我们称为顺序查找（sequential search）。

示例图：

无序链表的顺序查找在最坏情况下，查找和插入的时间复杂度都是 N 级别的，平均情况下查找是 N/2 级别，但插入还是 N 级别。我们希望能找到更高效的实现，不管是查找还是插入，于是先来了解下有序（可比较类型，下面使用 compareTo() 方法）数组的二分查找。

实现的关键是 rank() 方法，它会返回符号表中比给定键值小的键的数目。对于 get() 来说，rank() 准确地告诉我们去哪找（找不到就不在表中）。对于 put() 来说，rank() 准确地告诉我们去哪更新表中存在的键的值，或是要把新的键值对放在哪。插入新键值对时，我们把较大的键都后移一位来腾出位置，以此来维护有序性。

插入图例：

查找图例：

代码：

public void put(Key key, Value val) {
    int i = rank(key);
    // key is already in table
    if (i < N && keys[i].compareTo(key) == 0) {
        vals[i] = val;
        return;
    }
    // insert new key-value pair
    for (int j = N; j > i; j--) {
        keys[j] = keys[j--];
        vals[j] = vals[j--];
    }
    keys[i] = key;
    vals[i] = val;
    N++;
}

public Value get(Key key) {
    if (isEmpty()) return null;
    int i = rank(key);
    if (i < N && keys[i].compareTo(key) == 0) return vals[i];
    else return null;
}

private int rank(Key key) {
    int lo = 0, hi = N - 1;
    while (lo <= hi) {
        int mid = lo + (hi - lo) / 2;
        int cmp = key.compareTo(keys[mid]);
        if (cmp < 0) hi = mid - 1;
        else if (cmp > 0) lo = mid + 1;
        else return mid;
    }
    return lo;
}

这是简略版，完整的参见：BinarySearchST.java。

维护数组有序，就可以使用二分查找（上面的 rank() 方法）来大大减少比较的次数，和数组中间比完看在哪边再递归地处理，查找的复杂度最坏情况下也是 lgN 级别的。但最坏情况下，插入还是 N 级别，因为大的键都要后移，不过平均是 N/2 级别，比原来链表都是 N 高效。

ordered operations

有序数组里的键自然是可比较的，还有一些和顺序有关的便利的操作，API 如下：

这些操作还是很实用的，像下面的例子：

借助 rank() 方法，实现也比较简洁，如：

public Key ceiling(Key key) {
    int i = rank(key);
    return keys[i];
}

完整的参见：BinarySearchST.java。

综上，比较一下无序链表顺序查找和有序数组二分查找实现的符号表：

可见，二分查找的插入和删除还是有改进空间的。

BSTs

接着我们来了解一种更高效的符号表实现：二叉查找树，它结合了链表插入的灵活性和有序数组查找的快捷性，大概长这个样子：

具有显式的树结构，每个节点有两个链接。其中键是可比较的，且键大于左子树小于右子树。所以每个节点包含四个部分，键，值以及指向左右子树的引用：

private class Node {
    private Key key;
    private Value val;
    private Node left, right;
    public Node(Key key, Value val) {
        this.key = key;
        this.val = val;
    }
}

键大于左子树小于右子树，查找的时候自然就是一个二分的过程。

查找代码：

public Value get(Key key) {
    Node x = root;
    while (x != null) {
        int cmp = key.compareTo(x.key);
        if (cmp < 0) x = x.left;
        else if (cmp > 0) x = x.right;
        else return x.val;
    }
    return null;
}

查找图例：

类似的，插入过程也是二分查找找到合适的位置。

插入代码：

public void put(Key key, Value val) {
    root = put(root, key, val);
}

private Node put(Node x, Key key, Value val) {
    if (x == null) return new Node(key, val);
    int cmp = key.compareTo(x.key);
    if (cmp < 0) x.left = put(x.left, key, val);
    else if (cmp > 0) x.right = put(x.right, key, val);
    else x.val = val;
    return x;
}

插入图例：

上面的查找和插入的复杂度显然和树高相关，但是！二叉查找树的形状和输入有关，不一定都长得很好看，最坏情况下树高为 N，那就退化成链表实现了。

不过，其实二叉查找树和快排的划分过程存在对应关系：

于是乎，借用快排的结论，如果是随机插入的话，那平均情况下复杂度也是 lgN 级别的。

bst ordered operations

再先来看看二叉搜索树中和顺序相关的操作怎么实现。

Minimum and maximum

如果根节点的左链接为空的话，那么根节点即为最小键；不然最小键就在左子树，把左孩子当做新的根节点来看，继续找下去。找最大键类似，不过是把左换成右。

Floor and ceiling

如果给定的键小于根节点的键，那么向下取整（floor）一定在左子树。如果大于根节点的键，那么 floor 有可能在右子树（当右子树存在比给定键小的键时），不然就直接是根节点的键。向上取整（ceiling）类似，调换一下左右。

代码：

public Key floor(Key key) {
    Node x = floor(root, key);
    if (x == null) return null;
    return x.key;
}

private Node floor(Node x, Key key) {
    if (x == null) return null;
    int cmp = key.compareTo(x.key);

    if (cmp == 0) return x;
    if (cmp < 0) return floor(x.left, key);

    Node t = floor(x.right, key);
    if (t != null) return t;
    else return x;
}

图例：

Rank

rank() 方法返回给定键的排名，为此我们在每个节点中维护一个变量 count，表示以该节点为根的树的节点数，并用方法 size() 访问。

private class Node {
    private Key key;
    private Value val;
    private Node left;
    private Node right;
    private int count;
}

public int size() {
    return size(root);
}

private int size(Node x) {
    if (x == null) return 0;
    return x.count;
}

private Node put(Node x, Key key, Value val) {
    if (x == null) return new Node(key, val, 1);
    int cmp = key.compareTo(x.key);
    if (cmp < 0) x.left = put(x.left, key, val);
    else if (cmp > 0) x.right = put(x.rigth, key, val);
    else x.val = val;
    x.count = 1 + size(x.left) + size(x.right);
    return x;
}

于是乎，方法 rank() 长这样：

public int rank(Key key) {
    return rank(key, root);
}

private int rank(Key key, Node x) {
    if (x == null) return 0;
    int cmp = key.compareTo(x.key);
    if (cmp < 0) return rank(key, x.left);
    else if (cmp > 0) return 1 + size(x.left) + rank(x.right);
    else return size(x.left);
}

二叉搜索树中这些顺序相关的操作，它们的复杂度同样和树高脱不了干系，这里只是举了些例子，完整的参见：BST.java。

deletion

最后来说说二叉查找树中的删除操作，有种懒删除是把节点标记成无效的而实际还在树里，也就是把值直接置空，但随着输入的增长，这做法显然不可取，空间上就不允许。

其实，在二叉树搜索树里删除没孩子的或只有一个孩子的节点，还是比较容易的，空出来的一条链接置空或者连到孩子上就好。像删除有最小键的节点就是这样：

代码：

public void deleteMin() {
    root = deleteMin(root);
}

private Node deleteMin(Node x) {
    if (x.left == null) return x.right;
    x.left = deleteMin(x.left);
    x.count = 1 + size(x.left) + size(x.right);
    return x;
}

代码先一直向左，直到找到一个左链接为空的节点，返回该节点的右链接，最后更新子树的节点数。

图例：

头大的是删除有两个孩子的节点，只空出来一条链接要怎么安排两个孩子，有个 Hibbard 删除的策略是用待删节点的后继节点（即右子树中键最小的节点）代替它，这样删除该点之后二叉查找树还是有序的。

具体做法可以概括成三步：

• 找到待删节点 t 的后继节点 x，x 是 t 右子树中具有最小键的节点，x 没有左孩子。
• 删掉 t 右子树中最小键的节点 x，不要让它被垃圾回收机制处理。
• 把节点 x 放在 t 的位置上。

图例：

代码：

public void delete(Key key) {
    root = delete(root, key);
}

private Node delete(Node x, Key key) {
    if (x == null) return null;
    int cmp = key.compareTo(x.key);
    // search for key
    if (cmp < 0) x.left = delete(x.left, key);
    else if (cmp > 0) x.right = delete(x.right, key);
    else {
        if (x.right == null) return x.left;    // no right child
        if (x.left == null) return x.right;    // no left child
        // replace with successor
        Node t = x;
        x = min(t.right);
        x.right = deleteMin(t.right);
        x.left = t.left;
    }
    // update subtree counts
    x.count = size(x.left) + size(x.right) + 1;
    return x;
}

但是吧，Hibbard 删除里选后继节点是一个随意的决定，没有考虑树的对称性，为什么不选前继节点呢，实际上前继节点和后继节点的选择应该是随机的。一直是后继节点，可能会在某些实际应用中产生性能问题，大概就是树被删丑了的感觉。

维护一棵二叉查找树有”健康的“树高，或者说让二叉树平衡（左右子树差不多树也就低），是我们接下来要讨论的内容。