前言
符號表（Symbol Table）是一種存儲鍵值對的數據結構，可以支持快速查找操作。
符號表分爲有序和無序兩種，有序符號表主要指支持 min()、max() 等根據鍵的大小關係來實現的操作。
有序符號表的鍵需要實現 Comparable 接口。
public interface UnorderedST<Key, Value> {
int size();
Value get(Key key);
void put(Key key, Value value);
void delete(Key key);
}
public interface OrderedST<Key extends Comparable<Key>, Value> {
int size();
void put(Key key, Value value);
Value get(Key key);
Key min();
Key max();
int rank(Key key);
List<Key> keys(Key l, Key h);
}
初級實現
1. 鏈表實現無序符號表
public class ListUnorderedST<Key, Value> implements UnorderedST<Key, Value> {
private Node first;
private class Node {
Key key;
Value value;
Node next;
Node(Key key, Value value, Node next) {
this.key = key;
this.value = value;
this.next = next;
}
}
@Override
public int size() {
int cnt = 0;
Node cur = first;
while (cur != null) {
cnt++;
cur = cur.next;
}
return cnt;
}
@Override
public void put(Key key, Value value) {
Node cur = first;
// 如果在鏈表中找到節點的鍵等於 key 就更新這個節點的值爲 value
while (cur != null) {
if (cur.key.equals(key)) {
cur.value = value;
return;
}
cur = cur.next;
}
// 否則使用頭插法插入一個新節點
first = new Node(key, value, first);
}
@Override
public void delete(Key key) {
if (first == null)
return;
if (first.key.equals(key))
first = first.next;
Node pre = first, cur = first.next;
while (cur != null) {
if (cur.key.equals(key)) {
pre.next = cur.next;
return;
}
pre = pre.next;
cur = cur.next;
}
}
@Override
public Value get(Key key) {
Node cur = first;
while (cur != null) {
if (cur.key.equals(key))
return cur.value;
cur = cur.next;
}
return null;
}
}
2. 二分查找實現有序符號表
使用一對平行數組，一個存儲鍵一個存儲值。
二分查找的 rank() 方法至關重要，當鍵在表中時，它能夠知道該鍵的位置；當鍵不在表中時，它也能知道在何處插入新鍵。
二分查找最多需要 logN+1 次比較，使用二分查找實現的符號表的查找操作所需要的時間最多是對數級別的。但是插入操作需要移動數組元素，是線性級別的。
public class BinarySearchOrderedST<Key extends Comparable<Key>, Value> implements OrderedST<Key, Value> {
private Key[] keys;
private Value[] values;
private int N = 0;
public BinarySearchOrderedST(int capacity) {
keys = (Key[]) new Comparable[capacity];
values = (Value[]) new Object[capacity];
}
@Override
public int size() {
return N;
}
@Override
public int rank(Key key) {
int l = 0, h = N - 1;
while (l <= h) {
int m = l + (h - l) / 2;
int cmp = key.compareTo(keys[m]);
if (cmp == 0)
return m;
else if (cmp < 0)
h = m - 1;
else
l = m + 1;
}
return l;
}
@Override
public List<Key> keys(Key l, Key h) {
int index = rank(l);
List<Key> list = new ArrayList<>();
while (keys[index].compareTo(h) <= 0) {
list.add(keys[index]);
index++;
}
return list;
}
@Override
public void put(Key key, Value value) {
int index = rank(key);
// 如果找到已經存在的節點鍵爲 key，就更新這個節點的值爲 value
if (index < N && keys[index].compareTo(key) == 0) {
values[index] = value;
return;
}
// 否則在數組中插入新的節點，需要先將插入位置之後的元素都向後移動一個位置
for (int j = N; j > index; j--) {
keys[j] = keys[j - 1];
values[j] = values[j - 1];
}
keys[index] = key;
values[index] = value;
N++;
}
@Override
public Value get(Key key) {
int index = rank(key);
if (index < N && keys[index].compareTo(key) == 0)
return values[index];
return null;
}
@Override
public Key min() {
return keys[0];
}
@Override
public Key max() {
return keys[N - 1];
}
}
二叉查找樹
二叉樹 是一個空鏈接，或者是一個有左右兩個鏈接的節點，每個鏈接都指向一顆子二叉樹。
二叉查找樹 （BST）是一顆二叉樹，並且每個節點的值都大於等於其左子樹中的所有節點的值而小於等於右子樹的所有節點的值。
BST 有一個重要性質，就是它的中序遍歷結果遞增排序。
基本數據結構：
public class BST<Key extends Comparable<Key>, Value> implements OrderedST<Key, Value> {
protected Node root;
protected class Node {
Key key;
Value val;
Node left;
Node right;
// 以該節點爲根的子樹節點總數
int N;
// 紅黑樹中使用
boolean color;
Node(Key key, Value val, int N) {
this.key = key;
this.val = val;
this.N = N;
}
}
@Override
public int size() {
return size(root);
}
private int size(Node x) {
if (x == null)
return 0;
return x.N;
}
protected void recalculateSize(Node x) {
x.N = size(x.left) + size(x.right) + 1;
}
}
爲了方便繪圖，下文中二叉樹的空鏈接不畫出來。
1. get()
- 如果樹是空的，則查找未命中；
- 如果被查找的鍵和根節點的鍵相等，查找命中；
- 否則遞歸地在子樹中查找：如果被查找的鍵較小就在左子樹中查找，較大就在右子樹中查找。
@Override
public Value get(Key key) {
return get(root, key);
}
private Value get(Node x, Key key) {
if (x == null)
return null;
int cmp = key.compareTo(x.key);
if (cmp == 0)
return x.val;
else if (cmp < 0)
return get(x.left, key);
else
return get(x.right, key);
}
2. put()
當插入的鍵不存在於樹中，需要創建一個新節點，並且更新上層節點的鏈接指向該節點，使得該節點正確地鏈接到樹中。
@Override
public void put(Key key, Value value) {
root = put(root, key, value);
}
private Node put(Node x, Key key, Value value) {
if (x == null)
return new Node(key, value, 1);
int cmp = key.compareTo(x.key);
if (cmp == 0)
x.val = value;
else if (cmp < 0)
x.left = put(x.left, key, value);
else
x.right = put(x.right, key, value);
recalculateSize(x);
return x;
}
3. 分析
二叉查找樹的算法運行時間取決於樹的形狀，而樹的形狀又取決於鍵被插入的先後順序。
最好的情況下樹是完全平衡的，每條空鏈接和根節點的距離都爲 logN。
在最壞的情況下，樹的高度爲 N。
4. floor()
floor(key)：小於等於鍵的最大鍵
- 如果鍵小於根節點的鍵，那麼 floor(key) 一定在左子樹中；
- 如果鍵大於根節點的鍵，需要先判斷右子樹中是否存在 floor(key)，如果存在就返回，否則根節點就是 floor(key)。
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);
return t != null ? t : x;
}
5. rank()
rank(key) 返回 key 的排名。
- 如果鍵和根節點的鍵相等，返回左子樹的節點數；
- 如果小於，遞歸計算在左子樹中的排名；
- 如果大於，遞歸計算在右子樹中的排名，加上左子樹的節點數，再加上 1（根節點）。
@Override
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 size(x.left);
else if (cmp < 0)
return rank(key, x.left);
else
return 1 + size(x.left) + rank(key, x.right);
}
6. min()
@Override
public Key min() {
return min(root).key;
}
private Node min(Node x) {
if (x == null)
return null;
if (x.left == null)
return x;
return min(x.left);
}
7. deleteMin()
令指向最小節點的鏈接指向最小節點的右子樹。
public void deleteMin() {
root = deleteMin(root);
}
public Node deleteMin(Node x) {
if (x.left == null)
return x.right;
x.left = deleteMin(x.left);
recalculateSize(x);
return x;
}
8. delete()
- 如果待刪除的節點只有一個子樹， 那麼只需要讓指向待刪除節點的鏈接指向唯一的子樹即可；
- 否則，讓右子樹的最小節點替換該節點。
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);
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;
if (x.left == null)
return x.right;
Node t = x;
x = min(t.right);
x.right = deleteMin(t.right);
x.left = t.left;
}
recalculateSize(x);
return x;
}
9. keys()
利用二叉查找樹中序遍歷的結果爲遞增的特點。
@Override
public List<Key> keys(Key l, Key h) {
return keys(root, l, h);
}
private List<Key> keys(Node x, Key l, Key h) {
List<Key> list = new ArrayList<>();
if (x == null)
return list;
int cmpL = l.compareTo(x.key);
int cmpH = h.compareTo(x.key);
if (cmpL < 0)
list.addAll(keys(x.left, l, h));
if (cmpL <= 0 && cmpH >= 0)
list.add(x.key);
if (cmpH > 0)
list.addAll(keys(x.right, l, h));
return list;
}
10. 分析
二叉查找樹所有操作在最壞的情況下所需要的時間都和樹的高度成正比。
2-3 查找樹
2-3 查找樹引入了 2- 節點和 3- 節點，目的是爲了讓樹平衡。一顆完美平衡的 2-3 查找樹的所有空鏈接到根節點的距離應該是相同的。
1. 插入操作
插入操作和 BST 的插入操作有很大區別，BST 的插入操作是先進行一次未命中的查找，然後再將節點插入到對應的空鏈接上。但是 2-3 查找樹如果也這麼做的話，那麼就會破壞了平衡性。它是將新節點插入到葉子節點上。
根據葉子節點的類型不同，有不同的處理方式：
- 如果插入到 2- 節點上，那麼直接將新節點和原來的節點組成 3- 節點即可。
- 如果是插入到 3- 節點上，就會產生一個臨時 4- 節點時，需要將 4- 節點分裂成 3 個 2- 節點，並將中間的 2- 節點移到上層節點中。如果上移操作繼續產生臨時 4- 節點則一直進行分裂上移，直到不存在臨時 4- 節點。
2. 性質
2-3 查找樹插入操作的變換都是局部的，除了相關的節點和鏈接之外不必修改或者檢查樹的其它部分，而這些局部變換不會影響樹的全局有序性和平衡性。
2-3 查找樹的查找和插入操作複雜度和插入順序無關，在最壞的情況下查找和插入操作訪問的節點必然不超過 logN 個，含有 10 億個節點的 2-3 查找樹最多隻需要訪問 30 個節點就能進行任意的查找和插入操作。
紅黑樹
紅黑樹是 2-3 查找樹，但它不需要分別定義 2- 節點和 3- 節點，而是在普通的二叉查找樹之上，爲節點添加顏色。指向一個節點的鏈接顏色如果爲紅色，那麼這個節點和上層節點表示的是一個 3- 節點，而黑色則是普通鏈接。
紅黑樹具有以下性質：
- 紅鏈接都爲左鏈接；
- 完美黑色平衡，即任意空鏈接到根節點的路徑上的黑鏈接數量相同。
畫紅黑樹時可以將紅鏈接畫平。
public class RedBlackBST<Key extends Comparable<Key>, Value> extends BST<Key, Value> {
private static final boolean RED = true;
private static final boolean BLACK = false;
private boolean isRed(Node x) {
if (x == null)
return false;
return x.color == RED;
}
}
1. 左旋轉
因爲合法的紅鏈接都爲左鏈接，如果出現右鏈接爲紅鏈接，那麼就需要進行左旋轉操作。
public Node rotateLeft(Node h) {
Node x = h.right;
h.right = x.left;
x.left = h;
x.color = h.color;
h.color = RED;
x.N = h.N;
recalculateSize(h);
return x;
}
2. 右旋轉
進行右旋轉是爲了轉換兩個連續的左紅鏈接，這會在之後的插入過程中探討。
public Node rotateRight(Node h) {
Node x = h.left;
h.left = x.right;
x.right = h;
x.color = h.color;
h.color = RED;
x.N = h.N;
recalculateSize(h);
return x;
}
3. 顏色轉換
一個 4- 節點在紅黑樹中表現爲一個節點的左右子節點都是紅色的。分裂 4- 節點除了需要將子節點的顏色由紅變黑之外，同時需要將父節點的顏色由黑變紅，從 2-3 樹的角度看就是將中間節點移到上層節點。
void flipColors(Node h) {
h.color = RED;
h.left.color = BLACK;
h.right.color = BLACK;
}
4. 插入
先將一個節點按二叉查找樹的方法插入到正確位置，然後再進行如下顏色操作：
- 如果右子節點是紅色的而左子節點是黑色的，進行左旋轉；
- 如果左子節點是紅色的，而且左子節點的左子節點也是紅色的，進行右旋轉；
- 如果左右子節點均爲紅色的，進行顏色轉換。
@Override
public void put(Key key, Value value) {
root = put(root, key, value);
root.color = BLACK;
}
private Node put(Node x, Key key, Value value) {
if (x == null) {
Node node = new Node(key, value, 1);
node.color = RED;
return node;
}
int cmp = key.compareTo(x.key);
if (cmp == 0)
x.val = value;
else if (cmp < 0)
x.left = put(x.left, key, value);
else
x.right = put(x.right, key, value);
if (isRed(x.right) && !isRed(x.left))
x = rotateLeft(x);
if (isRed(x.left) && isRed(x.left.left))
x = rotateRight(x);
if (isRed(x.left) && isRed(x.right))
flipColors(x);
recalculateSize(x);
return x;
}
可以看到該插入操作和二叉查找樹的插入操作類似，只是在最後加入了旋轉和顏色變換操作即可。
根節點一定爲黑色，因爲根節點沒有上層節點，也就沒有上層節點的左鏈接指向根節點。flipColors() 有可能會使得根節點的顏色變爲紅色，每當根節點由紅色變成黑色時樹的黑鏈接高度加 1.
5. 分析
一顆大小爲 N 的紅黑樹的高度不會超過 2logN。最壞的情況下是它所對應的 2-3 樹，構成最左邊的路徑節點全部都是 3- 節點而其餘都是 2- 節點。
紅黑樹大多數的操作所需要的時間都是對數級別的。
散列表
散列表類似於數組，可以把散列表的散列值看成數組的索引值。訪問散列表和訪問數組元素一樣快速，它可以在常數時間內實現查找和插入操作。
由於無法通過散列值知道鍵的大小關係，因此散列表無法實現有序性操作。
1. 散列函數
對於一個大小爲 M 的散列表，散列函數能夠把任意鍵轉換爲 [0, M-1] 內的正整數，該正整數即爲 hash 值。
散列表存在衝突，也就是兩個不同的鍵可能有相同的 hash 值。
散列函數應該滿足以下三個條件：
- 一致性：相等的鍵應當有相等的 hash 值，兩個鍵相等表示調用 equals() 返回的值相等。
- 高效性：計算應當簡便，有必要的話可以把 hash 值緩存起來，在調用 hash 函數時直接返回。
- 均勻性：所有鍵的 hash 值應當均勻地分佈到 [0, M-1] 之間，如果不能滿足這個條件，有可能產生很多衝突，從而導致散列表的性能下降。
除留餘數法可以將整數散列到 [0, M-1] 之間，例如一個正整數 k，計算 k%M 既可得到一個 [0, M-1] 之間的 hash 值。注意 M 最好是一個素數，否則無法利用鍵包含的所有信息。例如 M 爲 10k，那麼只能利用鍵的後 k 位。
對於其它數，可以將其轉換成整數的形式，然後利用除留餘數法。例如對於浮點數，可以將其的二進制形式轉換成整數。
對於多部分組合的類型，每個部分都需要計算 hash 值，這些 hash 值都具有同等重要的地位。爲了達到這個目的，可以將該類型看成 R 進制的整數，每個部分都具有不同的權值。
例如，字符串的散列函數實現如下：
int hash = 0;
for (int i = 0; i < s.length(); i++)
hash = (R * hash + s.charAt(i)) % M;
再比如，擁有多個成員的自定義類的哈希函數如下：
int hash = (((day * R + month) % M) * R + year) % M;
R 通常取 31。
Java 中的 hashCode() 實現了哈希函數，但是默認使用對象的內存地址值。在使用 hashCode() 時，應當結合除留餘數法來使用。因爲內存地址是 32 位整數，我們只需要 31 位的非負整數，因此應當屏蔽符號位之後再使用除留餘數法。
int hash = (x.hashCode() & 0x7fffffff) % M;
使用 Java 的 HashMap 等自帶的哈希表實現時，只需要去實現 Key 類型的 hashCode() 函數即可。Java 規定 hashCode() 能夠將鍵均勻分佈於所有的 32 位整數，Java 中的 String、Integer 等對象的 hashCode() 都能實現這一點。以下展示了自定義類型如何實現 hashCode()：
public class Transaction {
private final String who;
private final Date when;
private final double amount;
public Transaction(String who, Date when, double amount) {
this.who = who;
this.when = when;
this.amount = amount;
}
public int hashCode() {
int hash = 17;
int R = 31;
hash = R * hash + who.hashCode();
hash = R * hash + when.hashCode();
hash = R * hash + ((Double) amount).hashCode();
return hash;
}
}
2. 拉鍊法
拉鍊法使用鏈表來存儲 hash 值相同的鍵，從而解決衝突。
查找需要分兩步，首先查找 Key 所在的鏈表，然後在鏈表中順序查找。
對於 N 個鍵，M 條鏈表 (N>M)，如果哈希函數能夠滿足均勻性的條件，每條鏈表的大小趨向於 N/M，因此未命中的查找和插入操作所需要的比較次數爲 ~N/M。
3. 線性探測法
線性探測法使用空位來解決衝突，當衝突發生時，向前探測一個空位來存儲衝突的鍵。
使用線性探測法，數組的大小 M 應當大於鍵的個數 N（M>N)。
public class LinearProbingHashST<Key, Value> implements UnorderedST<Key, Value> {
private int N = 0;
private int M = 16;
private Key[] keys;
private Value[] values;
public LinearProbingHashST() {
init();
}
public LinearProbingHashST(int M) {
this.M = M;
init();
}
private void init() {
keys = (Key[]) new Object[M];
values = (Value[]) new Object[M];
}
private int hash(Key key) {
return (key.hashCode() & 0x7fffffff) % M;
}
}
3.1 查找
public Value get(Key key) {
for (int i = hash(key); keys[i] != null; i = (i + 1) % M)
if (keys[i].equals(key))
return values[i];
return null;
}
3.2 插入
public void put(Key key, Value value) {
resize();
putInternal(key, value);
}
private void putInternal(Key key, Value value) {
int i;
for (i = hash(key); keys[i] != null; i = (i + 1) % M)
if (keys[i].equals(key)) {
values[i] = value;
return;
}
keys[i] = key;
values[i] = value;
N++;
}
3.3 刪除
刪除操作應當將右側所有相鄰的鍵值對重新插入散列表中。
public void delete(Key key) {
int i = hash(key);
while (keys[i] != null && !key.equals(keys[i]))
i = (i + 1) % M;
// 不存在，直接返回
if (keys[i] == null)
return;
keys[i] = null;
values[i] = null;
// 將之後相連的鍵值對重新插入
i = (i + 1) % M;
while (keys[i] != null) {
Key keyToRedo = keys[i];
Value valToRedo = values[i];
keys[i] = null;
values[i] = null;
N--;
putInternal(keyToRedo, valToRedo);
i = (i + 1) % M;
}
N--;
resize();
}
3.5 調整數組大小
線性探測法的成本取決於連續條目的長度，連續條目也叫聚簇。當聚簇很長時，在查找和插入時也需要進行很多次探測。例如下圖中 2~4 位置就是一個聚簇。
α = N/M，把 α 稱爲使用率。理論證明，當 α 小於 1/2 時探測的預計次數只在 1.5 到 2.5 之間。爲了保證散列表的性能，應當調整數組的大小，使得 α 在 [1/4, 1/2] 之間。
private void resize() {
if (N >= M / 2)
resize(2 * M);
else if (N <= M / 8)
resize(M / 2);
}
private void resize(int cap) {
LinearProbingHashST<Key, Value> t = new LinearProbingHashST<Key, Value>(cap);
for (int i = 0; i < M; i++)
if (keys[i] != null)
t.putInternal(keys[i], values[i]);
keys = t.keys;
values = t.values;
M = t.M;
}
小結
1. 符號表算法比較
| 算法 | 插入 | 查找 | 是否有序 |
|---|---|---|---|
| 鏈表實現的無序符號表 | N | N | yes |
| 二分查找實現的有序符號表 | N | logN | yes |
| 二叉查找樹 | logN | logN | yes |
| 2-3 查找樹 | logN | logN | yes |
| 拉鍊法實現的散列表 | N/M | N/M | no |
| 線性探測法實現的散列表 | 1 | 1 | no |
應當優先考慮散列表，當需要有序性操作時使用紅黑樹。
2. Java 的符號表實現
- java.util.TreeMap：紅黑樹
- java.util.HashMap：拉鍊法的散列表
3. 稀疏向量乘法
當向量爲稀疏向量時，可以使用符號表來存儲向量中的非 0 索引和值，使得乘法運算只需要對那些非 0 元素進行即可。
public class SparseVector {
private HashMap<Integer, Double> hashMap;
public SparseVector(double[] vector) {
hashMap = new HashMap<>();
for (int i = 0; i < vector.length; i++)
if (vector[i] != 0)
hashMap.put(i, vector[i]);
}
public double get(int i) {
return hashMap.getOrDefault(i, 0.0);
}
public double dot(SparseVector other) {
double sum = 0;
for (int i : hashMap.keySet())
sum += this.get(i) * other.get(i);
return sum;
}
}