feat(algorithms, data structures, binary search tree): inorder successor in bst

Author: BrianLusina

datastructures/trees/binary/search_tree/README.md

@@ -300,3 +300,65 @@ When the traversal hits the rightmost node, the stack will hold half of the n to
 so our worst case space cost is O(n).
 
 Bonus What if the input tree has duplicate values?
+
+---
+
+## Inorder Successor in BST
+
+You are given the root node of a binary search tree and a specific node p. Your task is to return the inorder successor 
+of this p node. If there is no inorder successor of the given node, return NULL.
+
+> Note: The inorder successor of p is the node with the smallest value greater than p.data in the binary search tree.
+
+**Constraints**
+
+- The tree contains nodes in the range [1, 500]
+- −10^4 ≤ `Node.data` ≤ 10^4 
+- All Nodes will have unique values. 
+- `p` should exist in the tree.
+
+### Examples
+
+![Example 1](./images/examples/inorder_successor_in_bst_example_1.png)
+![Example 2](./images/examples/inorder_successor_in_bst_example_2.png)
+![Example 3](./images/examples/inorder_successor_in_bst_example_3.png)
+
+## Solution
+
+To solve this problem, we will use the depth-first search pattern because it allows us to perform an inorder traversal 
+of the tree, which is necessary to find the inorder successor of a given node. 
+The properties of the BST allow us to make an efficient search by discarding half of the tree at each step. We start 
+from the root node and compare the value of the current node with p. It helps us decide whether to move to the left or 
+right subtree. If p is greater than or equal to the current node’s value, we move to the right subtree, as the in-order 
+successor must be in the right subtree or above the current node. Otherwise, we explore the left subtree to find a 
+potentially smaller successor. This way, we efficiently find the inorder successor of the given node. 
+
+Let’s go through the algorithm to see how we will reach the solution:
+
+- Initialize a variable successor to NULL. It stores the potential inorder successor as we traverse the tree. 
+- Traverse the tree starting from the root, and for each node, compare the values of p and root:
+  - If the value of p is greater than or equal to the value of the root, the inorder successor must be in the right 
+    subtree or higher up in the tree. We move to the right subtree by setting root = root.right. 
+  - Otherwise, we update the successor to the current node, as this node is a potential in-order successor. Then, move 
+    to the left subtree by setting root = root.left.
+
+- After the loop ends, we return the successor. This contains the inoder successor of the given node.
+
+> Note: If there was no in-order successor of the given node, the successor will remain NULL.
+
+![Solution 1](./images/solutions/inorder_successor_in_bst_solution_1.png)
+![Solution 2](./images/solutions/inorder_successor_in_bst_solution_2.png)
+![Solution 3](./images/solutions/inorder_successor_in_bst_solution_3.png)
+![Solution 4](./images/solutions/inorder_successor_in_bst_solution_4.png)
+![Solution 5](./images/solutions/inorder_successor_in_bst_solution_5.png)
+![Solution 6](./images/solutions/inorder_successor_in_bst_solution_6.png)
+![Solution 7](./images/solutions/inorder_successor_in_bst_solution_7.png)
+
+### Time Complexity
+
+The time complexity of this solution is O(n) in the worst-case scenario where the given tree is skewed. However, for a 
+balanced binary search tree, it will be O(logn).
+
+### Space Complexity
+
+The space complexity of the solution is O(1) because we don’t use any additional space.

datastructures/trees/binary/search_tree/__init__.py

@@ -12,6 +12,27 @@ def __init__(self, root: Optional[BinaryTreeNode] = None):
         super().__init__(root)
         self.stack = DynamicSizeStack()
 
+    def __len__(self) -> int:
+        if not self.root:
+            return 0
+
+        counter = 1
+        stack = DynamicSizeStack()
+        stack.push(self.root)
+
+        while not stack.is_empty():
+            node = stack.pop()
+
+            if node.left:
+                counter += 1
+                stack.push(node.left)
+
+            if node.right:
+                counter += 1
+                stack.push(node.right)
+
+        return counter
+
     @staticmethod
     def construct_bst(items: List[T]) -> Optional["BinarySearchTree"]:
         """
@@ -42,7 +63,7 @@ def construct_bst_helper(left: int, right: int) -> Optional[BinaryTreeNode]:
 
         return BinarySearchTree(root=construct_bst_helper(0, len(items) - 1))
 
-    def insert_node(self, data: T):
+    def insert_node(self, data: Optional[T]):
         """
         Inserts a node in a BST given an element
         If there is no root, then create a new root node with the data and return it
@@ -64,7 +85,8 @@ def insert_helper(value: T, node: BinaryTreeNode) -> BinaryTreeNode:
                 node.right = insert_helper(value, node.right)
             return node
 
-        insert_helper(data, self.root)
+        if data:
+            insert_helper(data, self.root)
 
     def delete_node(self, key: T) -> Optional[BinaryTreeNode]:
         """Deletes a node from the Binary Search Tree. If the node is found, it is deleted and the tree re-ordered to
@@ -116,6 +138,7 @@ def delete_helper(
                 else:
                     node.right = lift(node.right, node)
                     return node
+            return None
 
         def lift(
             node: BinaryTreeNode, node_to_delete: BinaryTreeNode
@@ -660,6 +683,7 @@ def search_helper(current: Optional[BinaryTreeNode], value: T) -> bool:
                     return search_helper(current.right, value)
                 else:
                     return search_helper(current.left, value)
+            return False
 
         return search_helper(self.root, data)
 
@@ -801,23 +825,43 @@ def paths(self) -> list:
 
         return [list(map(int, x.split("->"))) for x in res]
 
-    def __len__(self) -> int:
-        if not self.root:
-            return 0
+    def inorder_successor(self, node: BinaryTreeNode) -> Optional[BinaryTreeNode]:
+        """
+        Returns the inorder successor of the node. If there is no node, None is returned. The inorder successor of the
+        node is the node with the smallest value greater than node.data in the binary search tree.
 
-        counter = 1
-        stack = DynamicSizeStack()
-        stack.push(self.root)
+        This assumes that the node is in the tree already.
 
-        while not stack.is_empty():
-            node = stack.pop()
+        Complexity:
 
-            if node.left:
-                counter += 1
-                stack.push(node.left)
+        Time Complexity: The time complexity of this solution is O(n) in the worst-case scenario where the given tree
+        is skewed. However, for a balanced binary search tree, it will be O(logn).
 
-            if node.right:
-                counter += 1
-                stack.push(node.right)
+        Space Complexity: O(1) because we don't use any additional space.
 
-        return counter
+        Args:
+            node (BinaryTreeNode): node to search for inorder successor
+        Returns:
+            Optional[BinaryTreeNode]: returns inorder successor of node if available, else None
+        """
+        if not self.root:
+            return None
+
+        successor = None
+        current = self.root
+
+        # current is the best candidate so far
+        while current:
+            # when current.data is greater than the node.data, we have found a valid successor, so, we save it in the
+            # successor variable
+            if current.data > node.data:
+                successor = current
+                # Move left to find a better(smaller) candidate. By moving to current.left, we are exploring values that
+                # are smaller than current.data. Since we want the smallest possible successor, we must check the left
+                # side of current to see if there is a node that is still greater than node.data, but close to node.data
+                current = current.left
+            else:
+                # this node is too small, so we must go right to find a larger value
+                current = current.right
+
+        return successor