no message

Author: wuduhren

problems/python3/binary-tree-right-side-view.py

@@ -0,0 +1,18 @@
+"""
+Time: O(N)
+Space: O(LogN) if the tree is balanced.
+
+BFS is a more intuitive way to do this, but the time complexity will be at least O(N).
+Using recursion instead, will take O(LogN) for the recursion stack size.
+"""
+class Solution:
+    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
+        def helper(node, level):
+            if not node: return
+            if len(ans)<level: ans.append(node.val)
+            helper(node.right, level+1)
+            helper(node.left, level+1)
+        
+        ans = []
+        helper(root, 1)
+        return ans

problems/python3/count-good-nodes-in-binary-tree.py

@@ -0,0 +1,16 @@
+"""
+Time: O(N)
+Space: O(LogN) for recursion stack if the tree is balanced.
+"""
+class Solution:
+    def goodNodes(self, root: TreeNode) -> int:
+        def helper(node, maxVal):
+            nonlocal count            
+            if not node: return
+            if node.val>=maxVal: count += 1
+            helper(node.left, max(maxVal, node.val))
+            helper(node.right, max(maxVal, node.val))
+        
+        count = 0
+        helper(root, float('-inf'))
+        return count

problems/python3/validate-binary-search-tree.py

@@ -0,0 +1,24 @@
+"""
+The inorder travsersal of a BST is always increasing.
+
+Time: O(N)
+Space: O(N)
+"""
+class Solution:
+    def isValidBST(self, root: Optional[TreeNode]) -> bool:
+        lastVal = float('-inf')
+        stack = []
+        
+        node = root
+        while stack or node:
+            while node:
+                stack.append(node)
+                node = node.left
+            
+            node = stack.pop()
+            
+            if not lastVal<node.val: return False
+            lastVal = node.val
+            
+            node = node.right
+        return True