Create 230_kthSmallestElementBST.py

Author: duncanmichel

LeetCode/230_kthSmallestElementBST.py

@@ -0,0 +1,144 @@
+"""
+Level: MEDIUM
+https://leetcode.com/problems/kth-smallest-element-in-a-bst/
+
+57 ms with test data
+
+
+Runtime
+57 ms
+Beats
+81.22%
+Memory
+18 MB
+Beats
+45.99%
+"""
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
+        def countup(node):
+            if node is None:
+                return 0
+            else:
+                return 1 + countup(node.left) + countup(node.right)
+
+        def goback(node):
+            if node is None:
+                return -1
+            nodecount = countup(node.left) + 1
+            if nodecount == k:
+                return node.val
+            elif nodecount < k and node.right is not None:
+                return self.kthSmallest(node.right,k-nodecount)
+            elif nodecount > k and node.left is not None:
+                return goback(node.left)
+            else:
+                return -1
+            
+        return goback(root)
+
+
+"""
+36ms with test data
+
+Runtime
+47 ms
+Beats
+96.77%
+Memory
+18.1 MB
+Beats
+16.44%
+"""
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
+        def goback(node,count):
+            if node is None:
+                return (-1,0)
+            leftans, leftcount = goback(node.left,count)
+            if leftcount == k:
+                return (leftans,leftcount)
+            nodecount = leftcount + count + 1
+            #print(f"node {node.val}, count {nodecount}, parentcount {count}")
+            if nodecount == k:
+                return (node.val,nodecount)
+            rightans,rightcount = goback(node.right,nodecount)
+            if rightcount == k:
+                return (rightans,rightcount)
+            return (rightans,leftcount+rightcount+1)
+            
+        ans,count = goback(root,0)
+        return ans
+
+
+"""
+In order traversal with stack
+class Solution:
+    def kthSmallest(self, root: TreeNode, k: int) -> int:
+        stack = []
+        res = []
+        while stack or root:
+            while root:
+                stack.append(root)
+                root = root.left
+            root = stack.pop()
+            res.append(root)
+            root = root.right
+        return res[k-1].val
+
+recursive in order traversal with early stopping
+def kthSmallest_dfs_early_stopping(self, root, k):
+	res = []
+	def _inorder(node):
+		if not node: return
+		_inorder(node.left)
+		if len(res) == k:
+			return
+		res.append(node.val)
+		_inorder(node.right)
+	_inorder(root)
+	return res[-1]
+
+
+Faster 98.65% Memory 99.79% || TC : O(N) || SC: O(1) MORRIS TRAVERSAL
+
+def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
+        
+        pos = 0
+        ans = 0
+        
+        current = root
+        
+        while current and pos < k:
+            
+            if not current.left:
+                pos += 1
+                ans = current.val
+                current = current.right
+            
+            else:
+                pre = current.left
+                while pre.right:
+                    pre = pre.right
+                
+                pre.right = current
+                left = current.left
+                current.left = None
+                current = left
+        
+        return ans
+"""
+