Merge pull request #1 from CyC2018/master

常规更新主仓库最新更新

docs/notes/Java 容器.md

@@ -56,7 +56,7 @@
 
 - HashMap：基于哈希表实现。
 
-- HashTable：和 HashMap 类似，但它是线程安全的，这意味着同一时刻多个线程可以同时写入 HashTable 并且不会导致数据不一致。它是遗留类，不应该去使用它。现在可以使用 ConcurrentHashMap 来支持线程安全，并且 ConcurrentHashMap 的效率会更高，因为 ConcurrentHashMap 引入了分段锁。
+- Hashtable：和 HashMap 类似，但它是线程安全的，这意味着同一时刻多个线程可以同时写入 Hashtable 并且不会导致数据不一致。它是遗留类，不应该去使用它。现在可以使用 ConcurrentHashMap 来支持线程安全，并且 ConcurrentHashMap 的效率会更高，因为 ConcurrentHashMap 引入了分段锁。
 
 - LinkedHashMap：使用双向链表来维护元素的顺序，顺序为插入顺序或者最近最少使用（LRU）顺序。
 
@@ -810,9 +810,9 @@ static final int tableSizeFor(int cap) {
 
 从 JDK 1.8 开始，一个桶存储的链表长度大于等于 8 时会将链表转换为红黑树。
 
-### 9. 与 HashTable 的比较
+### 9. 与 Hashtable 的比较
 
-- HashTable 使用 synchronized 来进行同步。
+- Hashtable 使用 synchronized 来进行同步。
 - HashMap 可以插入键为 null 的 Entry。
 - HashMap 的迭代器是 fail-fast 迭代器。
 - HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。

docs/notes/Leetcode 题解 - 动态规划.md

@@ -134,7 +134,7 @@ private int rob(int[] nums, int first, int last) {
 
 定义一个数组 dp 存储错误方式数量，dp[i] 表示前 i 个信和信封的错误方式数量。假设第 i 个信装到第 j 个信封里面，而第 j 个信装到第 k 个信封里面。根据 i 和 k 是否相等，有两种情况：
 
-- i==k，交换 i 和 k 的信后，它们的信和信封在正确的位置，但是其余 i-2 封信有 dp[i-2] 种错误装信的方式。由于 j 有 i-1 种取值，因此共有 (i-1)\*dp[i-2] 种错误装信方式。
+- i==k，交换 i 和 j 的信后，它们的信和信封在正确的位置，但是其余 i-2 封信有 dp[i-2] 种错误装信的方式。由于 j 有 i-1 种取值，因此共有 (i-1)\*dp[i-2] 种错误装信方式。
 - i != k，交换 i 和 j 的信后，第 i 个信和信封在正确的位置，其余 i-1 封信有 dp[i-1] 种错误装信方式。由于 j 有 i-1 种取值，因此共有 (i-1)\*dp[i-1] 种错误装信方式。
 
 综上所述，错误装信数量方式数量为：
@@ -869,22 +869,18 @@ return -1.
 
 ```java
 public int coinChange(int[] coins, int amount) {
-    if (amount == 0 || coins == null || coins.length == 0) {
+public int change(int amount, int[] coins) {
+    if (coins == null) {
         return 0;
     }
     int[] dp = new int[amount + 1];
+    dp[0] = 1;
     for (int coin : coins) {
-        for (int i = coin; i <= amount; i++) { //将逆序遍历改为正序遍历
-            if (i == coin) {
-                dp[i] = 1;
-            } else if (dp[i] == 0 && dp[i - coin] != 0) {
-                dp[i] = dp[i - coin] + 1;
-            } else if (dp[i - coin] != 0) {
-                dp[i] = Math.min(dp[i], dp[i - coin] + 1);
-            }
+        for (int i = coin; i <= amount; i++) {
+            dp[i] += dp[i - coin];
         }
     }
-    return dp[amount] == 0 ? -1 : dp[amount];
+    return dp[amount];
 }
 ```
 
@@ -906,9 +902,6 @@ Explanation: there are four ways to make up the amount:
 
 ```java
 public int change(int amount, int[] coins) {
-    if (amount == 0 || coins == null || coins.length == 0) {
-        return 0;
-    }
     int[] dp = new int[amount + 1];
     dp[0] = 1;
     for (int coin : coins) {

docs/notes/数据库系统原理.md

@@ -316,7 +316,7 @@ SELECT ... FOR UPDATE;
 MVCC 在每行记录后面都保存着两个隐藏的列，用来存储两个版本号：
 
 - 创建版本号：指示创建一个数据行的快照时的系统版本号；
-- 删除版本号：如果该快照的删除版本号大于当前事务版本号表示该快照有效，否则表示该快照已经被删除了。
+- 删除版本号：如果该快照的删除版本未定义或删除版本号大于当前事务版本号表示该快照有效
 
 ## Undo 日志
 
@@ -392,14 +392,14 @@ SELECT c FROM t WHERE c BETWEEN 10 and 20 FOR UPDATE;
 
 ## Next-Key Locks
 
-它是 Record Locks 和 Gap Locks 的结合，不仅锁定一个记录上的索引，也锁定索引之间的间隙。例如一个索引包含以下值：10, 11, 13, and 20，那么就需要锁定以下区间：
+它是 Record Locks 和 Gap Locks 的结合，不仅锁定一个记录上的索引，也锁定索引之间的间隙，是一个前开后闭区间。例如一个索引包含以下值：10, 11, 13, and 20，那么就需要锁定以下区间：
 
 ```sql
 (-∞, 10]
 (10, 11]
 (11, 13]
 (13, 20]
-(20, +∞)
+(20, +supremum)
 ```
 
 # 七、关系数据库设计理论

notes/Java 容器.md

@@ -56,7 +56,7 @@
 
 - HashMap：基于哈希表实现。
 
-- HashTable：和 HashMap 类似，但它是线程安全的，这意味着同一时刻多个线程可以同时写入 HashTable 并且不会导致数据不一致。它是遗留类，不应该去使用它。现在可以使用 ConcurrentHashMap 来支持线程安全，并且 ConcurrentHashMap 的效率会更高，因为 ConcurrentHashMap 引入了分段锁。
+- Hashtable：和 HashMap 类似，但它是线程安全的，这意味着同一时刻多个线程可以同时写入 Hashtable 并且不会导致数据不一致。它是遗留类，不应该去使用它。现在可以使用 ConcurrentHashMap 来支持线程安全，并且 ConcurrentHashMap 的效率会更高，因为 ConcurrentHashMap 引入了分段锁。
 
 - LinkedHashMap：使用双向链表来维护元素的顺序，顺序为插入顺序或者最近最少使用（LRU）顺序。
 
@@ -810,9 +810,9 @@ static final int tableSizeFor(int cap) {
 
 从 JDK 1.8 开始，一个桶存储的链表长度大于等于 8 时会将链表转换为红黑树。
 
-### 9. 与 HashTable 的比较
+### 9. 与 Hashtable 的比较
 
-- HashTable 使用 synchronized 来进行同步。
+- Hashtable 使用 synchronized 来进行同步。
 - HashMap 可以插入键为 null 的 Entry。
 - HashMap 的迭代器是 fail-fast 迭代器。
 - HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。

notes/Leetcode 题解 - 动态规划.md

@@ -134,7 +134,7 @@ private int rob(int[] nums, int first, int last) {
 
 定义一个数组 dp 存储错误方式数量，dp[i] 表示前 i 个信和信封的错误方式数量。假设第 i 个信装到第 j 个信封里面，而第 j 个信装到第 k 个信封里面。根据 i 和 k 是否相等，有两种情况：
 
-- i==k，交换 i 和 k 的信后，它们的信和信封在正确的位置，但是其余 i-2 封信有 dp[i-2] 种错误装信的方式。由于 j 有 i-1 种取值，因此共有 (i-1)\*dp[i-2] 种错误装信方式。
+- i==k，交换 i 和 j 的信后，它们的信和信封在正确的位置，但是其余 i-2 封信有 dp[i-2] 种错误装信的方式。由于 j 有 i-1 种取值，因此共有 (i-1)\*dp[i-2] 种错误装信方式。
 - i != k，交换 i 和 j 的信后，第 i 个信和信封在正确的位置，其余 i-1 封信有 dp[i-1] 种错误装信方式。由于 j 有 i-1 种取值，因此共有 (i-1)\*dp[i-1] 种错误装信方式。
 
 综上所述，错误装信数量方式数量为：
@@ -869,22 +869,18 @@ return -1.
 
 ```java
 public int coinChange(int[] coins, int amount) {
-    if (amount == 0 || coins == null || coins.length == 0) {
+public int change(int amount, int[] coins) {
+    if (coins == null) {
         return 0;
     }
     int[] dp = new int[amount + 1];
+    dp[0] = 1;
     for (int coin : coins) {
-        for (int i = coin; i <= amount; i++) { //将逆序遍历改为正序遍历
-            if (i == coin) {
-                dp[i] = 1;
-            } else if (dp[i] == 0 && dp[i - coin] != 0) {
-                dp[i] = dp[i - coin] + 1;
-            } else if (dp[i - coin] != 0) {
-                dp[i] = Math.min(dp[i], dp[i - coin] + 1);
-            }
+        for (int i = coin; i <= amount; i++) {
+            dp[i] += dp[i - coin];
         }
     }
-    return dp[amount] == 0 ? -1 : dp[amount];
+    return dp[amount];
 }
 ```
 

notes/数据库系统原理.md

@@ -316,7 +316,7 @@ SELECT ... FOR UPDATE;
 MVCC 在每行记录后面都保存着两个隐藏的列，用来存储两个版本号：
 
 - 创建版本号：指示创建一个数据行的快照时的系统版本号；
-- 删除版本号：如果该快照的删除版本号大于当前事务版本号表示该快照有效，否则表示该快照已经被删除了。
+- 删除版本号：如果该快照的删除版本未定义或删除版本号大于当前事务版本号表示该快照有效
 
 ## Undo 日志
 
@@ -392,14 +392,14 @@ SELECT c FROM t WHERE c BETWEEN 10 and 20 FOR UPDATE;
 
 ## Next-Key Locks
 
-它是 Record Locks 和 Gap Locks 的结合，不仅锁定一个记录上的索引，也锁定索引之间的间隙。例如一个索引包含以下值：10, 11, 13, and 20，那么就需要锁定以下区间：
+它是 Record Locks 和 Gap Locks 的结合，不仅锁定一个记录上的索引，也锁定索引之间的间隙，是一个前开后闭区间。例如一个索引包含以下值：10, 11, 13, and 20，那么就需要锁定以下区间：
 
 ```sql
 (-∞, 10]
 (10, 11]
 (11, 13]
 (13, 20]
-(20, +∞)
+(20, +supremum)
 ```
 
 # 七、关系数据库设计理论