Merge pull request #550 from KelvinG-611/98. Validate-Binary-Search-Tree

98. validate binary search tree

problems/0098.验证二叉搜索树.md

@@ -337,6 +337,8 @@ class Solution {
 ```
 
 Python：
+
+**递归** - 利用BST中序遍历特性,把树"压缩"成数组
 ```python
 # Definition for a binary tree node.
 # class TreeNode:
@@ -344,29 +346,56 @@ Python：
 #         self.val = val
 #         self.left = left
 #         self.right = right
-# 递归法
 class Solution:
     def isValidBST(self, root: TreeNode) -> bool:
-        res = []  //把二叉搜索树按中序遍历写成list
-        def buildalist(root):
-            if not root: return  
-            buildalist(root.left)  //左
-            res.append(root.val)  //中
-            buildalist(root.right)  //右
-            return res  
-        buildalist(root)
-        return res == sorted(res) and len(set(res)) == len(res) //检查list里的数有没有重复元素，以及是否按从小到大排列
+        # 思路: 利用BST中序遍历的特性.
+        # 中序遍历输出的二叉搜索树节点的数值是有序序列
+        candidate_list = []
+        
+        def __traverse(root: TreeNode) -> None: 
+            nonlocal candidate_list
+            if not root: 
+                return 
+            __traverse(root.left)
+            candidate_list.append(root.val)
+            __traverse(root.right)
+            
+        def __is_sorted(nums: list) -> bool: 
+            for i in range(1, len(nums)): 
+                if nums[i] <= nums[i - 1]: # ⚠️ 注意: Leetcode定义二叉搜索树中不能有重复元素
+                    return False
+            return True
+        
+        __traverse(root)
+        res = __is_sorted(candidate_list)
+        
+        return res
+```
 
-# 简单递归法
+**递归** - 标准做法
+
+```python
 class Solution:
     def isValidBST(self, root: TreeNode) -> bool:
-        def isBST(root, min_val, max_val):
-            if not root: return True
-            if root.val >= max_val or root.val <= min_val:
+        # 规律: BST的中序遍历节点数值是从小到大. 
+        cur_max = -float("INF")
+        def __isValidBST(root: TreeNode) -> bool: 
+            nonlocal cur_max
+            
+            if not root: 
+                return True
+            
+            is_left_valid = __isValidBST(root.left)
+            if cur_max < root.val: 
+                cur_max = root.val
+            else: 
                 return False
-            return isBST(root.left, min_val, root.val) and isBST(root.right, root.val, max_val)
-        return isBST(root, float("-inf"), float("inf"))
-
+            is_right_valid = __isValidBST(root.right)
+            
+            return is_left_valid and is_right_valid
+        return __isValidBST(root)
+```
+```
 # 迭代-中序遍历
 class Solution:
     def isValidBST(self, root: TreeNode) -> bool: