fix code

Author: lighting9999

binary_search_trees/delete_a_node_in_bst.py

@@ -1,35 +1,36 @@
+from typing import Optional
 from inorder_successor import inorder_successor
+from tree_node import Node
+
 # The above line imports the inorder_successor function from the inorder_successor.py file
-def delete_node(root,val):
-  """ This function deletes a node with value val from the BST"""
-  
-  # search in the left subtree
-  if root.data < val:
-    root.right = delete_node(root.right,val)
+def delete_node(root: Node, val: int) -> Optional[Node]:
+    """This function deletes a node with value val from the BST"""
 
-  # search in the right subtree
-  elif root.data>val:
-    root.left=delete_node(root.left,val)
+    # Search in the right subtree
+    if root.data < val:
+        root.right = delete_node(root.right, val)
 
-  # node to be deleted is found
-  else:
-    # case 1: no child leaf node
-    if root.left is None and root.right is None:
-      return None
+    # Search in the left subtree
+    elif root.data > val:
+        root.left = delete_node(root.left, val)
 
-    # case 2: one child
-    if root.left is None:
-      return root.right
-    
-    # case 2: one child
-    elif root.right is None:
-      return root.left
-    
-    # case 3: two children
-    
-    # find the inorder successor
-    IS=inorder_successor(root.right)
-    root.data=IS.data
-    root.right=delete_node(root.right,IS.data)
-  return root
-    
+    # Node to be deleted is found
+    else:
+        # Case 1: No child (leaf node)
+        if root.left is None and root.right is None:
+            return None
+        
+        # Case 2: One child
+        if root.left is None:
+            return root.right
+        
+        # Case 2: One child
+        elif root.right is None:
+            return root.left
+        
+        # Case 3: Two children
+        # Find the inorder successor
+        is_node: Node = inorder_successor(root.right)
+        root.data = is_node.data
+        root.right = delete_node(root.right, is_node.data)
+    return root

binary_search_trees/inorder_successor.py

@@ -1,10 +1,12 @@
-def inorder_successor(root):
-  # This function returns the inorder successor of a node in a BST
-  
-  # The inorder successor of a node is the node with the smallest value greater than the value of the node
-  current=root
-  
-  # The inorder successor is the leftmost node in the right subtree
-  while current.left is not None:
-    current=current.left
-  return current
+from tree_node import Node
+
+def inorder_successor(root: Node) -> Node:
+    """This function returns the inorder successor of a node in a BST"""
+    
+    # The inorder successor of a node is the node with the smallest value greater than the value of the node
+    current: Node = root
+    
+    # The inorder successor is the leftmost node in the right subtree
+    while current.left is not None:
+        current = current.left
+    return current

binary_search_trees/inorder_traversal.py

@@ -1,5 +1,8 @@
-def inorder(root):
-    """ This function performs an inorder traversal of a BST"""
+from typing import Optional
+from tree_node import Node
+
+def inorder(root: Optional[Node]) -> None:
+    """This function performs an inorder traversal of a BST"""
 
     # The inorder traversal of a BST is the nodes in increasing order
     if root is None:

binary_search_trees/insert_in_bst.py

@@ -1,17 +1,18 @@
+from typing import Optional
 from tree_node import Node
-def insert(root,val):
-    
-    """ This function inserts a node with value val into the BST"""
+
+def insert(root: Optional[Node], val: int) -> Node:
+    """This function inserts a node with value val into the BST"""
 
     # If the tree is empty, create a new node
     if root is None:
         return Node(val)
 
     # If the value to be inserted is less than the root value, insert in the left subtree
     if val < root.data:
-        root.left = insert(root.left,val)
+        root.left = insert(root.left, val)
 
     # If the value to be inserted is greater than the root value, insert in the right subtree
     else:
-        root.right = insert(root.right,val)
+        root.right = insert(root.right, val)
     return root

binary_search_trees/main.py

@@ -1,16 +1,16 @@
+from typing import Optional
 from insert_in_bst import insert
 from delete_a_node_in_bst import delete_node
 from search_in_bst import search
 from mirror_a_bst import create_mirror_bst
 from print_in_range import print_in_range
 from root_to_leaf_paths import print_root_to_leaf_paths
 from validate_bst import is_valid_bst
+from tree_node import Node
 
-
-def main():
-    
+def main() -> None:
     # Create a BST
-    root = None
+    root: Optional[Node] = None
     root = insert(root, 50)
     root = insert(root, 30)
     root = insert(root, 20)
@@ -28,56 +28,55 @@ def main():
     print_root_to_leaf_paths(root, [])
 
     # Check if the tree is a BST
-    print("Is the tree a BST:", is_valid_bst(root,None,None))
+    print("Is the tree a BST:", is_valid_bst(root, None, None))
 
 
     # Delete nodes from the BST
     print("Deleting 20 from the BST:")
-    root = delete_node(root, 20)
+    if root is not None:
+        root = delete_node(root, 20)
 
     # Print the inorder traversal of the BST
     print("Inorder traversal of the BST after deleting 20:")
     print_in_range(root, 10, 90)
 
     # Check if the tree is a BST
-    print("Is the tree a BST:", is_valid_bst(root,None,None))
+    print("Is the tree a BST:", is_valid_bst(root, None, None))
 
 
     # Delete nodes from the BST
     print("Deleting 30 from the BST:")
-    root = delete_node(root, 30)
+    if root is not None:
+        root = delete_node(root, 30)
 
     # Print the inorder traversal of the BST after deleting 30
     print("Inorder traversal of the BST after deleting 30:")
     print_in_range(root, 10, 90)
 
     # Check if the tree is a BST
-    print("Is the tree a BST:", is_valid_bst(root,None,None))
+    print("Is the tree a BST:", is_valid_bst(root, None, None))
 
     # Delete nodes from the BST
     print("Deleting 50 from the BST:")
-    root = delete_node(root, 50)
+    if root is not None:
+        root = delete_node(root, 50)
 
     # Print the inorder traversal of the BST after deleting 50
     print("Inorder traversal of the BST after deleting 50:")
     print_in_range(root, 10, 90)
 
     # Check if the tree is a BST
-    print("Is the tree a BST:", is_valid_bst(root,None,None))
+    print("Is the tree a BST:", is_valid_bst(root, None, None))
 
 
     print("Searching for 70 in the BST:", search(root, 70))
     print("Searching for 100 in the BST:", search(root, 100))
     print("Inorder traversal of the BST:")
     print_in_range(root, 10, 90)
     print("Creating a mirror of the BST:")
-    mirror_root = create_mirror_bst(root)
+    mirror_root: Optional[Node] = create_mirror_bst(root)
     print("Inorder traversal of the mirror BST:")
     print_in_range(mirror_root, 10, 90)
 
 if __name__ == "__main__":
-    main()
-
-
-
-
+    main()

binary_search_trees/mirror_a_bst.py

@@ -1,15 +1,18 @@
-def create_mirror_bst(root):
-    """ Function to create a mirror of a binary search tree"""
+from typing import Optional
+from tree_node import Node
+
+def create_mirror_bst(root: Optional[Node]) -> Optional[Node]:
+    """Function to create a mirror of a binary search tree"""
 
     # If the tree is empty, return None
     if root is None:
         return None
 
-    # Create a new node with the root value
-    
     # Recursively create the mirror of the left and right subtrees
-    left_mirror = create_mirror_bst(root.left)
-    right_mirror = create_mirror_bst(root.right)
+    left_mirror: Optional[Node] = create_mirror_bst(root.left)
+    right_mirror: Optional[Node] = create_mirror_bst(root.right)
+    
+    # Swap left and right subtrees
     root.left = right_mirror
     root.right = left_mirror
     return root

binary_search_trees/print_in_range.py

@@ -1,21 +1,23 @@
-def print_in_range(root,k1,k2):
-  
-  """ This function prints the nodes in a BST that are in the range k1 to k2 inclusive"""
-  
-  # If the tree is empty, return
-  if root is None:
-    return
-  
-  # If the root value is in the range, print the root value
-  if root.data >= k1 and root.data <= k2:
-    print_in_range(root.left,k1,k2)
-    print(root.data)
-    print_in_range(root.right,k1,k2)
+from typing import Optional
+from tree_node import Node
+
+def print_in_range(root: Optional[Node], k1: int, k2: int) -> None:
+    """This function prints the nodes in a BST that are in the range k1 to k2 inclusive"""
 
-  # If the root value is less than k1, the nodes in the range will be in the right subtree
-  elif root.data < k1:
-    print_in_range(root.left,k1,k2)
+    # If the tree is empty, return
+    if root is None:
+        return
 
-  # If the root value is greater than k2, the nodes in the range will be in the left subtree
-  else:
-    print_in_range(root.right,k1,k2)
+    # If the root value is in the range, print the root value
+    if k1 <= root.data <= k2:
+        print_in_range(root.left, k1, k2)
+        print(root.data)
+        print_in_range(root.right, k1, k2)
+    
+    # If the root value is less than k1, the nodes in the range will be in the right subtree
+    elif root.data < k1:
+        print_in_range(root.right, k1, k2)  # Fixed: original had left, which is incorrect
+
+    # If the root value is greater than k2, the nodes in the range will be in the left subtree
+    else:
+        print_in_range(root.left, k1, k2)  # Fixed: original had right, which is incorrect

binary_search_trees/root_to_leaf_paths.py

@@ -1,5 +1,8 @@
-def print_root_to_leaf_paths(root, path):
-    """ This function prints all the root to leaf paths in a BST"""
+from typing import Optional, List
+from tree_node import Node
+
+def print_root_to_leaf_paths(root: Optional[Node], path: List[int]) -> None:
+    """This function prints all the root to leaf paths in a BST"""
 
     # If the tree is empty, return
     if root is None:

binary_search_trees/search_in_bst.py

@@ -1,8 +1,11 @@
-def search(root, val):
-    """ This function searches for a node with value val in the BST and returns True if found, False otherwise"""
+from typing import Optional
+from tree_node import Node
+
+def search(root: Optional[Node], val: int) -> bool:
+    """This function searches for a node with value val in the BST and returns True if found, False otherwise"""
 
     # If the tree is empty, return False
-    if root == None:
+    if root is None:
         return False
 
     # If the root value is equal to the value to be searched, return True

binary_search_trees/tree_node.py

@@ -1,8 +1,8 @@
+from typing import Optional
 
 # Node class for binary tree
-
 class Node:
-    def __init__(self, data):
-        self.data = data
-        self.left = None
-        self.right = None
+    def __init__(self, data: int) -> None:
+        self.data: int = data
+        self.left: Optional[Node] = None
+        self.right: Optional[Node] = None