Update 0530.二叉搜索树的最小绝对差.md

problems/0530.二叉搜索树的最小绝对差.md

@@ -204,66 +204,82 @@ class Solution {
 ```
 ## Python 
 
-递归
+递归法（版本一）利用中序递增，结合数组
 ```python
 class Solution:
-    def getMinimumDifference(self, root: TreeNode) -> int:
+    def __init__(self):
-        res = []   
+        self.vec = []
-        r = float("inf")
-        def buildaList(root):  //把二叉搜索树转换成有序数组
-            if not root: return None
-            if root.left: buildaList(root.left)  //左
-            res.append(root.val)  //中
-            if root.right: buildaList(root.right)  //右
-            return res
 
-        buildaList(root)
+    def traversal(self, root):
-        for i in range(len(res)-1):  // 统计有序数组的最小差值
+        if root is None:
-            r = min(abs(res[i]-res[i+1]),r)
+            return
-        return r
-        
-        
-class Solution: # 双指针法，不用数组 (同Carl写法) - 更快
-    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
-        global pre,minval
-        pre = None
-        minval = 10**5
-        self.traversal(root)
-        return minval
-
-    def traversal(self,root):
-        global pre,minval
-        if not root: return None
         self.traversal(root.left)
-        if pre and root.val-pre.val<minval: 
+        self.vec.append(root.val)  # 将二叉搜索树转换为有序数组
-            minval = root.val-pre.val
-        pre = root
         self.traversal(root.right)
-```
 
-
+    def getMinimumDifference(self, root):
-迭代法-中序遍历
+        self.vec = []
-```python 
+        self.traversal(root)
-class Solution:
+        if len(self.vec) < 2:
-    def getMinimumDifference(self, root: TreeNode) -> int:
+            return 0
-        stack = []
-        cur = root
-        pre = None
         result = float('inf')
-        while cur or stack:
+        for i in range(1, len(self.vec)):
-            if cur: # 指针来访问节点，访问到最底层
+            # 统计有序数组的最小差值
-                stack.append(cur)
+            result = min(result, self.vec[i] - self.vec[i - 1])
-                cur = cur.left
-            else: # 逐一处理节点
-                cur = stack.pop()
-                if pre: # 当前节点和前节点的值的差值
-                    result = min(result, abs(cur.val - pre.val))
-                pre = cur
-                cur = cur.right
         return result
 
 ```
 
+
+
+递归法（版本二）利用中序递增，找到该树最小值
+```python 
+class Solution:
+    def __init__(self):
+        self.result = float('inf')
+        self.pre = None
+
+    def traversal(self, cur):
+        if cur is None:
+            return
+        self.traversal(cur.left)  # 左
+        if self.pre is not None:  # 中
+            self.result = min(self.result, cur.val - self.pre.val)
+        self.pre = cur  # 记录前一个
+        self.traversal(cur.right)  # 右
+
+    def getMinimumDifference(self, root):
+        self.traversal(root)
+        return self.result
+
+        
+```
+
+迭代法
+```python 
+class Solution:
+    def getMinimumDifference(self, root):
+        stack = []
+        cur = root
+        pre = None
+        result = float('inf')
+
+        while cur is not None or len(stack) > 0:
+            if cur is not None:
+                stack.append(cur)  # 将访问的节点放进栈
+                cur = cur.left  # 左
+            else:
+                cur = stack.pop()
+                if pre is not None:  # 中
+                    result = min(result, cur.val - pre.val)
+                pre = cur
+                cur = cur.right  # 右
+
+        return result
+
+
+        
+```
 ## Go： 
 
 中序遍历，然后计算最小差值