Update 算法 - 符号表.md

代码经本地对拍验证；二分查找符号表的 keys(l, h) 补充 index < N，线性探测哈希表的缩容条件改为 N > 0 且 N <= M / 8；哈希值的范围、hashCode() 的约定按 Javadoc 更新，补充红黑树与 AVL 树的比较。

notes/算法 - 符号表.md

@@ -201,7 +201,7 @@ public class BinarySearchOrderedST<Key extends Comparable<Key>, Value> implement
     public List<Key> keys(Key l, Key h) {
         int index = rank(l);
         List<Key> list = new ArrayList<>();
-        while (keys[index].compareTo(h) <= 0) {
+        while (index < N && keys[index].compareTo(h) <= 0) {
             list.add(keys[index]);
             index++;
         }
@@ -333,7 +333,7 @@ private Value get(Node x, Key key) {
 <div align="center"> <img src="pics/st-bst-put.png" width="470px"/> </div><br>
 
 ```java
- @Override
+@Override
 public void put(Key key, Value value) {
     root = put(root, key, value);
 }
@@ -680,6 +680,8 @@ private Node put(Node x, Key key, Value value) {
 
 红黑树大多数的操作所需要的时间都是对数级别的。
 
+与同样保证对数高度的 AVL 树相比：AVL 树要求左右子树的高度差不超过 1，树更矮，查找略快，但删除节点时可能要沿着路径旋转多次；经典红黑树（例如 java.util.TreeMap 的实现）插入最多旋转 2 次、删除最多旋转 3 次，增删的代价更低。因此需要频繁增删的场景多用红黑树，例如 TreeMap、HashMap 中树化的桶和 Linux 内核的 rbtree。
+
 ## 哈希表
 
 哈希表类似于数组，可以把哈希表的哈希值看成数组的索引值。访问哈希表和访问数组元素一样快速，它可以在常数时间内实现查找和插入操作。
@@ -688,7 +690,7 @@ private Node put(Node x, Key key, Value value) {
 
 ### 1. 哈希函数
 
-对于一个大小为 M 的哈希表，哈希函数能够把任意键转换为 [0, M-1] 内的正整数，该正整数即为 hash 值。
+对于一个大小为 M 的哈希表，哈希函数能够把任意键转换为 [0, M-1] 内的非负整数，该整数即为 hash 值。
 
 哈希表存在冲突，也就是两个不同的键可能有相同的 hash 值。
 
@@ -698,7 +700,7 @@ private Node put(Node x, Key key, Value value) {
 - 高效性：计算应当简便，有必要的话可以把 hash 值缓存起来，在调用 hash 函数时直接返回。
 - 均匀性：所有键的 hash 值应当均匀地分布到 [0, M-1] 之间，如果不能满足这个条件，有可能产生很多冲突，从而导致哈希表的性能下降。
 
-除留余数法可以将整数映射到 [0, M-1] 之间，例如一个正整数 k，计算 k%M 既可得到一个 [0, M-1] 之间的 hash 值。注意 M 最好是一个素数，否则无法利用键包含的所有信息。例如 M 为 10<sup>k</sup>，那么只能利用键的后 k 位。
+除留余数法可以将整数映射到 [0, M-1] 之间，例如一个正整数 k，计算 k%M 即可得到一个 [0, M-1] 之间的 hash 值。注意 M 最好是一个素数，否则无法利用键包含的所有信息。例如 M 为 10<sup>k</sup>，那么只能利用键的后 k 位。
 
 对于其它数，可以将其转换成整数的形式，然后利用除留余数法。例如对于浮点数，可以将其的二进制形式转换成整数。
 
@@ -726,7 +728,7 @@ Java 中的 hashCode() 实现了哈希函数，在使用 hashCode() 时，应当
 int hash = (x.hashCode() & 0x7fffffff) % M;
 ```
 
-使用 Java 的 HashMap 等自带的哈希表实现时，只需要去实现 Key 类型的 hashCode() 函数即可。Java 规定 hashCode() 能够将键均匀分布于所有的 32 位整数，Java 中的 String、Integer 等对象的 hashCode() 都能实现这一点。以下展示了自定义类型如何实现 hashCode()：
+使用 Java 的 HashMap 等自带的哈希表实现时，只需要去实现 Key 类型的 hashCode() 函数（以及 equals()）即可。hashCode() 返回一个 32 位整数，Java 只要求相等的对象返回相同的值，哈希表的性能则取决于 hashCode() 能否把不同的键均匀地分散开。以下展示了自定义类型如何实现 hashCode()：
 
 ```java
 public class Transaction {
@@ -866,7 +868,7 @@ public void delete(Key key) {
 }
 ```
 
-##### 3.5 调整数组大小
+##### 3.4 调整数组大小
 
 线性探测法的成本取决于连续条目的长度，连续条目也叫聚簇。当聚簇很长时，在查找和插入时也需要进行很多次探测。例如下图中 2\~4 位置就是一个聚簇。
 
@@ -879,7 +881,7 @@ public void delete(Key key) {
 private void resize() {
     if (N >= M / 2)
         resize(2 * M);
-    else if (N <= M / 8)
+    else if (N > 0 && N <= M / 8)
         resize(M / 2);
 }