D. J.:

- Added the leetcode problem and solution for 98, 230 and 530

Author: nobodyPerfecZ

README.md

@@ -37,6 +37,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [71 Simplify Path](https://leetcode.com/problems/simplify-path/description/)
 - [80 Remove Duplicates from Sorted Array II](https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/description/)
 - [88 Merge Sorted Array](https://leetcode.com/problems/merge-sorted-array/description/)
+- [98 Validate Binary Search Tree](https://leetcode.com/problems/validate-binary-search-tree/description/)
 - [100 Same Tree](https://leetcode.com/problems/same-tree/description/)
 - [101 Symmetric Tree](https://leetcode.com/problems/symmetric-tree/description/)
 - [102 Binary Tree Level Order Traversal](https://leetcode.com/problems/binary-tree-level-order-traversal/description/)
@@ -70,12 +71,14 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [226 Invert Binary Tree](https://leetcode.com/problems/invert-binary-tree/description/)
 - [227 Basic Calculator II](https://leetcode.com/problems/basic-calculator-ii/description/)
 - [228 Summary Ranges](https://leetcode.com/problems/summary-ranges/description/)
+- [230 Kth Smallest Element in a BST](https://leetcode.com/problems/kth-smallest-element-in-a-bst/description/)
 - [236 Lowest Common Ancestor of a Binary Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
 - [242 Valid Anagram](https://leetcode.com/problems/valid-anagram/description/)
 - [290 Word Pattern](https://leetcode.com/problems/word-pattern/description/)
 - [383 Ransom Note](https://leetcode.com/problems/ransom-note/description/)
 - [392 Is Subsequence](https://leetcode.com/problems/is-subsequence/description/)
 - [452 Minimum Number of Arrows to Burst Balloons](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/description/)
+- [530 Minimum Absolute Difference in BST](https://leetcode.com/problems/minimum-absolute-difference-in-bst/description/)
 - [637 Average of Levels in Binary Tree](https://leetcode.com/problems/average-of-levels-in-binary-tree/description/)
 
 ## Development 🔧

awesome_python_leetcode/_230_kth_smallest_element_in_a_bst.py

@@ -0,0 +1,28 @@
+from typing import Optional
+
+from awesome_python_leetcode.tree import TreeNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
+        """
+        Given the root of a binary search tree, and an integer k, return the kth
+        smallest value (1-indexed) of all the values of the nodes in the tree.
+        """
+        res = 0
+
+        def dfs(root: Optional[TreeNode]):
+            nonlocal res, k
+            if root is None:
+                return
+            else:
+                dfs(root.left)
+                if k > 0:
+                    res = root.val
+                    k -= 1
+                dfs(root.right)
+
+        dfs(root)
+        return res

awesome_python_leetcode/_530_minimum_absolute_difference_in_bst.py

@@ -0,0 +1,27 @@
+from typing import Optional
+
+from awesome_python_leetcode.tree import TreeNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
+        """
+        Given the root of a Binary Search Tree (BST), return the minimum absolute
+        difference between the values of any two different nodes in the tree.
+        """
+        prev, res = None, float("inf")
+
+        def dfs(root: Optional[TreeNode]):
+            nonlocal prev, res
+            if root is None:
+                return
+            dfs(root.left)
+            if prev:
+                res = min(res, abs(root.val - prev.val))
+            prev = root
+            dfs(root.right)
+
+        dfs(root)
+        return res

awesome_python_leetcode/_98_validate_binary_search_tree.py

@@ -0,0 +1,33 @@
+from typing import Optional
+
+from awesome_python_leetcode.tree import TreeNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def isValidBST(self, root: Optional[TreeNode]) -> bool:
+        """
+        Given the root of a binary tree, determine if it is a valid binary search
+        tree (BST).
+
+        A valid BST is defined as follows:
+        - The left subtree of a node contains only nodes with keys less than the node's
+        key.
+        - The right subtree of a node contains only nodes with keys greater than the
+        node's key.
+        - Both the left and right subtrees must also be binary search trees.
+        """
+
+        def dfs(root: Optional[TreeNode], left: int, right: int):
+            if root is None:
+                return True
+            else:
+                return (
+                    dfs(root.left, left, root.val)
+                    and dfs(root.right, root.val, right)
+                    and left < root.val
+                    and root.val < right
+                )
+
+        return dfs(root, -float("inf"), +float("inf"))

tests/test_230_kth_smallest_element_in_a_bst.py

@@ -0,0 +1,20 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._230_kth_smallest_element_in_a_bst import Solution
+from awesome_python_leetcode.tree import TreeNode
+
+
+@pytest.mark.parametrize(
+    argnames=["root", "k", "expected"],
+    argvalues=[
+        ([3, 1, 4, None, 2], 1, 1),
+        ([5, 3, 6, 2, 4, None, None, 1], 3, 3),
+    ],
+)
+def test_func(root: List[int], k: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    root = TreeNode.build(root)
+    kth_smallest = Solution().kthSmallest(root, k)
+    assert kth_smallest == expected

tests/test_530_minimum_absolute_difference_in_bst.py

@@ -0,0 +1,17 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._530_minimum_absolute_difference_in_bst import Solution
+from awesome_python_leetcode.tree import TreeNode
+
+
+@pytest.mark.parametrize(
+    argnames=["root", "expected"],
+    argvalues=[([4, 2, 6, 1, 3], 1), ([1, 0, 48, None, None, 12, 49], 1)],
+)
+def test_func(root: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
+    root = TreeNode.build(root)
+    minimum_difference = Solution().getMinimumDifference(root)
+    assert minimum_difference == expected

tests/test_98_validate_binary_search_tree.py

@@ -0,0 +1,21 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._98_validate_binary_search_tree import Solution
+from awesome_python_leetcode.tree import TreeNode
+
+
+@pytest.mark.parametrize(
+    argnames=["root", "expected"],
+    argvalues=[
+        ([2, 1, 3], True),
+        ([5, 1, 4, None, None, 3, 6], False),
+        ([32, 26, 47, 19, None, None, 56, None, 27], False),
+    ],
+)
+def test_func(root: List[int], expected: bool):
+    """Tests the solution of a LeetCode problem."""
+    root = TreeNode.build(root)
+    is_valid_bst = Solution().isValidBST(root)
+    assert is_valid_bst == expected