Fix ruff lint: Optional → X | None, sort imports, wrap long docstring

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: keon

algorithms/data_structures/bst.py

@@ -14,28 +14,26 @@
 """
 from __future__ import annotations
 
-from typing import Optional
-
 
 class Node:
     def __init__(self, data: int) -> None:
         self.data: int = data
-        self.left: Optional[Node] = None
-        self.right: Optional[Node] = None
+        self.left: Node | None = None
+        self.right: Node | None = None
 
 
 class BST:
     def __init__(self) -> None:
-        self.root: Optional[Node] = None
+        self.root: Node | None = None
 
-    def get_root(self) -> Optional[Node]:
+    def get_root(self) -> Node | None:
         return self.root
 
     def size(self) -> int:
         """Return the number of nodes in the tree. Complexity: O(n)."""
         return self._recur_size(self.root)
 
-    def _recur_size(self, root: Optional[Node]) -> int:
+    def _recur_size(self, root: Node | None) -> int:
         if root is None:
             return 0
         return 1 + self._recur_size(root.left) + self._recur_size(root.right)
@@ -44,7 +42,7 @@ def search(self, data: int) -> bool:
         """Return True if data exists in the tree. Complexity: O(log n) average."""
         return self._recur_search(self.root, data)
 
-    def _recur_search(self, root: Optional[Node], data: int) -> bool:
+    def _recur_search(self, root: Node | None, data: int) -> bool:
         if root is None:
             return False
         if root.data == data:
@@ -55,7 +53,11 @@ def _recur_search(self, root: Optional[Node], data: int) -> bool:
             return self._recur_search(root.left, data)
 
     def insert(self, data: int) -> bool:
-        """Insert data into the tree. Return False if data already exists. Complexity: O(log n) average."""
+        """Insert data into the tree.
+
+        Return False if data already exists.
+        Complexity: O(log n) average.
+        """
         if self.root:
             return self._recur_insert(self.root, data)
         else:
@@ -78,7 +80,7 @@ def _recur_insert(self, root: Node, data: int) -> bool:
                 root.right = Node(data)
                 return True
 
-    def preorder(self, root: Optional[Node]) -> list[int]:
+    def preorder(self, root: Node | None) -> list[int]:
         """Return list of node values in preorder (root, left, right)."""
         result: list[int] = []
         if root:
@@ -87,7 +89,7 @@ def preorder(self, root: Optional[Node]) -> list[int]:
             result.extend(self.preorder(root.right))
         return result
 
-    def inorder(self, root: Optional[Node]) -> list[int]:
+    def inorder(self, root: Node | None) -> list[int]:
         """Return list of node values in inorder (left, root, right)."""
         result: list[int] = []
         if root:
@@ -96,7 +98,7 @@ def inorder(self, root: Optional[Node]) -> list[int]:
             result.extend(self.inorder(root.right))
         return result
 
-    def postorder(self, root: Optional[Node]) -> list[int]:
+    def postorder(self, root: Node | None) -> list[int]:
         """Return list of node values in postorder (left, right, root)."""
         result: list[int] = []
         if root:

tests/test_sorting.py

@@ -3,7 +3,6 @@
 from algorithms.sorting import (
     bitonic_sort,
     bogo_sort,
-    insertion_sort,
     bubble_sort,
     bucket_sort,
     cocktail_shaker_sort,
@@ -12,6 +11,7 @@
     cycle_sort,
     exchange_sort,
     gnome_sort,
+    insertion_sort,
     max_heap_sort,
     merge_sort,
     min_heap_sort,