go -> python

Author: dashidhy

advanced_algorithm/binary_search_tree.md

@@ -11,160 +11,127 @@
 
 > 验证二叉搜索树
 
-```go
-/**
- * Definition for a binary tree node.
- * type TreeNode struct {
- *     Val int
- *     Left *TreeNode
- *     Right *TreeNode
- * }
- */
-func isValidBST(root *TreeNode) bool {
-    return dfs(root).valid
-}
-type ResultType struct{
-    max int
-    min int
-    valid bool
-}
-func dfs(root *TreeNode)(result ResultType){
-    if root==nil{
-        result.max=-1<<63
-        result.min=1<<63-1
-        result.valid=true
-        return
-    }
-
-    left:=dfs(root.Left)
-    right:=dfs(root.Right)
-
-    // 1、满足左边最大值<root<右边最小值 && 左右两边valid
-    if root.Val>left.max && root.Val<right.min && left.valid && right.valid {
-        result.valid=true
-    }
-    // 2、更新当前节点的最大最小值
-    result.max=Max(Max(left.max,right.max),root.Val)
-    result.min=Min(Min(left.min,right.min),root.Val)
-    return
-}
-func Max(a,b int)int{
-    if a>b{
-        return a
-    }
-    return b
-}
-func Min(a,b int)int{
-    if a>b{
-        return b
-    }
-    return a
-}
-
+```Python
+class Solution:
+    def isValidBST(self, root: TreeNode) -> bool:
+        
+        if root is None:
+            return True
+        
+        s = [(root, float('-inf'), float('inf'))]
+        while len(s) > 0:
+            node, low, up = s.pop()
+            if node.left is not None:
+                if node.left.val <= low or node.left.val >= node.val:
+                    return False
+                s.append((node.left, low, node.val))
+            if node.right is not None:
+                if node.right.val <= node.val or node.right.val >= up:
+                    return False
+                s.append((node.right, node.val, up))
+        return True
 ```
 
 [insert-into-a-binary-search-tree](https://leetcode-cn.com/problems/insert-into-a-binary-search-tree/)
 
 > 给定二叉搜索树（BST）的根节点和要插入树中的值，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 保证原始二叉搜索树中不存在新值。
 
-```go
-func insertIntoBST(root *TreeNode, val int) *TreeNode {
-    if root==nil{
-        return &TreeNode{Val:val}
-    }
-    if root.Val<val{
-        root.Right=insertIntoBST(root.Right,val)
-    }else{
-        root.Left=insertIntoBST(root.Left,val)
-    }
-    return root
-}
+```Python
+class Solution:
+    def insertIntoBST(self, root: TreeNode, val: int) -> TreeNode:
+        
+        if root is None:
+            return TreeNode(val)
+        
+        if val > root.val:
+            root.right = self.insertIntoBST(root.right, val)
+        else:
+            root.left = self.insertIntoBST(root.left, val)
+        
+        return root
 ```
 
 [delete-node-in-a-bst](https://leetcode-cn.com/problems/delete-node-in-a-bst/)
 
 > 给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的  key  对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。
 
-```go
-/**
- * Definition for a binary tree node.
- * type TreeNode struct {
- *     Val int
- *     Left *TreeNode
- *     Right *TreeNode
- * }
- */
-func deleteNode(root *TreeNode, key int) *TreeNode {
-    // 删除节点分为三种情况：
-    // 1、只有左节点 替换为右
-    // 2、只有右节点 替换为左
-    // 3、有左右子节点 左子节点连接到右边最左节点即可
-    if root ==nil{
-        return root
-    }
-    if root.Val<key{
-        root.Right=deleteNode(root.Right,key)
-    }else if root.Val>key{
-        root.Left=deleteNode(root.Left,key)
-    }else if root.Val==key{
-        if root.Left==nil{
-            return root.Right
-        }else if root.Right==nil{
-            return root.Left
-        }else{
-            cur:=root.Right
-            // 一直向左找到最后一个左节点即可
-            for cur.Left!=nil{
-                cur=cur.Left
-            }
-            cur.Left=root.Left
-            return root.Right
-        }
-    }
-    return root
-}
+```Python
+class Solution:
+    def deleteNode(self, root: TreeNode, key: int) -> TreeNode:
+        
+        # try to find the node
+        dummy = TreeNode(left=root)
+        parent, node = dummy, root
+        isleft = True
+        while node is not None and node.val != key:
+            parent = node
+            isleft = key < node.val
+            node = node.left if isleft else node.right 
+        
+        # if found
+        if node is not None:
+            if node.right is None:
+                if isleft:
+                    parent.left = node.left
+                else:
+                    parent.right = node.left
+            elif node.left is None:
+                if isleft:
+                    parent.left = node.right
+                else:
+                    parent.right = node.right
+            else: 
+                p, n = node, node.left
+                while n.right is not None:
+                    p, n = n, n.right
+                if p != node:
+                    p.right = n.left
+                else:
+                    p.left = n.left
+                n.left, n.right = node.left, node.right
+                if isleft:
+                    parent.left = n
+                else:
+                    parent.right = n
+        
+        return dummy.left   
 ```
 
 [balanced-binary-tree](https://leetcode-cn.com/problems/balanced-binary-tree/)
 
 > 给定一个二叉树，判断它是否是高度平衡的二叉树。
 
-```go
-type ResultType struct{
-    height int
-    valid bool
-}
-func isBalanced(root *TreeNode) bool {
-    return dfs(root).valid
-}
-func dfs(root *TreeNode)(result ResultType){
-    if root==nil{
-        result.valid=true
-        result.height=0
-        return
-    }
-    left:=dfs(root.Left)
-    right:=dfs(root.Right)
-    // 满足所有特点：二叉搜索树&&平衡
-    if left.valid&&right.valid&&abs(left.height,right.height)<=1{
-        result.valid=true
-    }
-    result.height=Max(left.height,right.height)+1
-    return
-}
-func abs(a,b int)int{
-    if a>b{
-        return a-b
-    }
-    return b-a
-}
-func Max(a,b int)int{
-    if a>b{
-        return a
-    }
-    return b
-}
-
+```Python
+class Solution:
+    def isBalanced(self, root: TreeNode) -> bool:
+        
+        # post-order iterative
+        
+        s = [[TreeNode(), -1, -1]]
+        node, last = root, None
+        while len(s) > 1 or node is not None:
+            if node is not None:
+                s.append([node, -1, -1])
+                node = node.left
+                if node is None:
+                    s[-1][1] = 0
+            else:
+                peek = s[-1][0]
+                if peek.right is not None and last != peek.right:
+                    node = peek.right
+                else:
+                    if peek.right is None:
+                        s[-1][2] = 0
+                    last, dl, dr = s.pop()
+                    if abs(dl - dr) > 1:
+                        return False
+                    d = max(dl, dr) + 1
+                    if s[-1][1] == -1:
+                        s[-1][1] = d
+                    else:
+                        s[-1][2] = d
+        
+        return True
 ```
 
 ## 练习