98

Author: wind-liang

SUMMARY.md

@@ -97,4 +97,5 @@
 * [94. Binary Tree Inorder Traversal](leetCode-94-Binary-Tree-Inorder-Traversal.md)
 * [95. Unique Binary Search Trees II](leetCode-95-Unique-Binary-Search-TreesII.md)
 * [96. Unique Binary Search Trees](leetCode-96-Unique-Binary-Search-Trees.md)
-* [97. Interleaving String](leetCode-97-Interleaving-String.md)
+* [97. Interleaving String](leetCode-97-Interleaving-String.md)
+* [98. Validate Binary Search Tree](leetCode-98-Validate-Binary-Search-Tree.md)

leetCode-42-Trapping-Rain-Water.md

@@ -108,13 +108,23 @@ public int trap(int[] height) {
     }
     return sum;
 }
+
+private int getMax(int[] height) {
+    int max = 0;
+    for (int i = 0; i < height.length; i++) {
+        if (height[i] > max) {
+            max = height[i];
+        }
+    }
+    return max;
+}
 ```
 
 时间复杂度：如果最大的数是 m，个数是 n，那么就是 O（m * n）。
 
 空间复杂度： O （1）。
 
-下边讲一下， leetcode [solution](https://leetcode.com/problems/trapping-rain-water/solution/) 提供的 4 个算法。
+经过他人提醒，这个解法现在 AC 不了了，会报超时，但还是放在这里吧。 下边讲一下， leetcode [solution](https://leetcode.com/problems/trapping-rain-water/solution/) 提供的 4 个算法。
 
 # 解法二 按列求
 

leetCode-76-Minimum-Window-Substring.md

@@ -132,13 +132,13 @@ private boolean match(Map<Character, Integer> map) {
 }
 ```
 
-时间复杂度：O（n），n 是 S 的长度。
+时间复杂度：O（nm），n 是 S 的长度，match 函数消耗 O（m）。
 
 空间复杂度：O（m），m 是 T 的长度。
 
 参考[这里](<https://leetcode.com/problems/minimum-window-substring/discuss/26835/Java-4ms-bit-97.6>)，由于字符串中只有字母，我们其实可以不用 hashmap，可以直接用一个 int 数组，字母的 ascii 码值作为下标，保存每个字母的次数。
 
-此外，判断当前窗口是否含有所有字母，我们除了可以判断所有字母的次数是否小于等于 0，还可以用一个计数变量 count，把 count 初始化为 t 的长度，然后每次找到一个满足条件的字母，count 就减 1，如果 count 等于了 0，就代表包含了所有字母。
+此外，判断当前窗口是否含有所有字母，我们除了可以判断所有字母的次数是否小于等于 0，还可以用一个计数变量 count，把 count 初始化为 t 的长度，然后每次找到一个满足条件的字母，count 就减 1，如果 count 等于了 0，就代表包含了所有字母。这样的话，可以把之前的 match(map) 优化到 O（1）。
 
 ```java
 public String minWindow(String s, String t) {
@@ -192,8 +192,6 @@ public String minWindow(String s, String t) {
 }
 ```
 
-用数组改写以后时间复杂度没有变，但速度快了很多。
-
 # 总
 
 开始自己的思路偏了，一直往递归，动态规划的思想走，导致没想出来。对滑动窗口的应用的少，这次加深了印象。

leetCode-94-Binary-Tree-Inorder-Traversal.md

@@ -59,18 +59,18 @@ getAns(node.right, ans); //压栈
     / \   /
    4   5 6
 
- push   push   push   pop     push   pop    pop    pop 
-|   |  |   |  |_4_|  |   |   |_5_|  |   |  |   |  |   |  
-|   |  |_2_|  |_2_|  |_2_|   |_2_|  |_2_|  |   |  |   |
-|_1_|  |_1_|  |_1_|  |_1_|   |_1_|  |_1_|  |_1_|  |   |
-ans                  add 4          add 5  add 2   add 1
-[]                   [4]            [4 5]  [4 5 2][4 5 2 1]
+ push   push   push   pop     pop    push     pop     pop 
+|   |  |   |  |_4_|  |   |   |   |  |   |    |   |   |   |  
+|   |  |_2_|  |_2_|  |_2_|   |   |  |_5_|    |   |   |   |
+|_1_|  |_1_|  |_1_|  |_1_|   |_1_|  |_1_|    |_1_|   |   |
+ans                  add 4   add 2           add 5   add 1
+[]                   [4]     [4 2]           [4 2 5] [4 2 5 1]
  push   push   pop          pop 
 |   |  |   |  |   |        |   |  
 |   |  |_6_|  |   |        |   |  
 |_3_|  |_3_|  |_3_|        |   |
               add 6        add 3
-              [4 5 2 1 6]  [4 5 2 1 6 3]
+              [4 2 5 1 6]  [4 2 5 1 6 3]
 ```
 
 结合代码。