Add doctests for all helper functions in smooth_sort

- Added comprehensive doctests for all 7 helper functions
- All doctests pass successfully
- Addresses bot review feedback for test coverage

Author: aadr22

sorts/smooth_sort.py

@@ -66,6 +66,13 @@ def _generate_leonardo_numbers(max_value: int) -> list[int]:
     """
     Generate Leonardo numbers up to max_value.
     L(0) = 1, L(1) = 1, L(n) = L(n-1) + L(n-2) + 1
+
+    >>> _generate_leonardo_numbers(10)
+    [1, 1, 3, 5, 9, 15]
+    >>> _generate_leonardo_numbers(2)
+    [1, 1, 3]
+    >>> _generate_leonardo_numbers(0)
+    [1, 1]
     """
     leonardo = [1, 1]
     while leonardo[-1] < max_value:
@@ -74,26 +81,59 @@ def _generate_leonardo_numbers(max_value: int) -> list[int]:
 
 
 def _smooth_sort_build(arr: list[int], leonardo: list[int]) -> None:
-    """Build the Leonardo heap forest."""
+    """
+    Build the Leonardo heap forest.
+
+    >>> arr = [3, 1, 2]
+    >>> leo = _generate_leonardo_numbers(len(arr))
+    >>> _smooth_sort_build(arr, leo)
+    >>> arr  # Array is partially heapified
+    [3, 1, 2]
+    """
     for i in range(len(arr)):
         _add_to_heap(arr, i, leonardo)
 
 
 def _smooth_sort_extract(arr: list[int], leonardo: list[int]) -> None:
-    """Extract elements to produce sorted output."""
+    """
+    Extract elements to produce sorted output.
+
+    >>> arr = [3, 2, 1]
+    >>> leo = _generate_leonardo_numbers(len(arr))
+    >>> _smooth_sort_build(arr, leo)
+    >>> _smooth_sort_extract(arr, leo)
+    >>> arr
+    [1, 2, 3]
+    """
     for i in range(len(arr) - 1, 0, -1):
         _extract_from_heap(arr, i, leonardo)
 
 
 def _add_to_heap(arr: list[int], end: int, leonardo: list[int]) -> None:
-    """Add element at index 'end' to the Leonardo heap."""
+    """
+    Add element at index 'end' to the Leonardo heap.
+
+    >>> arr = [1, 3, 2]
+    >>> leo = _generate_leonardo_numbers(len(arr))
+    >>> _add_to_heap(arr, 2, leo)
+    >>> arr
+    [2, 3, 1]
+    """
     # This is a simplified version that focuses on correctness
     # We use a basic approach: maintain heap property up to 'end'
     _heapify_up(arr, end, leonardo)
 
 
 def _extract_from_heap(arr: list[int], end: int, leonardo: list[int]) -> None:
-    """Remove maximum element from heap ending at index 'end'."""
+    """
+    Remove maximum element from heap ending at index 'end'.
+
+    >>> arr = [5, 3, 4, 1, 2]
+    >>> leo = _generate_leonardo_numbers(len(arr))
+    >>> _extract_from_heap(arr, 4, leo)
+    >>> arr[4]  # Maximum moved to end
+    5
+    """
     # Find maximum in the range [0, end] and swap it to position 'end'
     max_idx = 0
     for i in range(1, end + 1):
@@ -107,7 +147,15 @@ def _extract_from_heap(arr: list[int], end: int, leonardo: list[int]) -> None:
 
 
 def _heapify_up(arr: list[int], index: int, leonardo: list[int]) -> None:
-    """Restore heap property from bottom up."""
+    """
+    Restore heap property from bottom up.
+
+    >>> arr = [1, 2, 5, 3]
+    >>> leo = _generate_leonardo_numbers(len(arr))
+    >>> _heapify_up(arr, 2, leo)
+    >>> arr
+    [5, 2, 1, 3]
+    """
     while index > 0:
         # Find parent using Leonardo number structure
         parent = _find_parent(index, leonardo)
@@ -119,7 +167,14 @@ def _heapify_up(arr: list[int], index: int, leonardo: list[int]) -> None:
 
 
 def _heapify_down(arr: list[int], index: int, end: int) -> None:
-    """Restore heap property from top down."""
+    """
+    Restore heap property from top down.
+
+    >>> arr = [1, 5, 3, 2, 4]
+    >>> _heapify_down(arr, 0, 4)
+    >>> arr
+    [5, 4, 3, 2, 1]
+    """
     while index < end:
         # Find children
         left = 2 * index + 1
@@ -139,7 +194,19 @@ def _heapify_down(arr: list[int], index: int, end: int) -> None:
 
 
 def _find_parent(index: int, leonardo: list[int]) -> int:
-    """Find parent index in Leonardo heap structure."""
+    """
+    Find parent index in Leonardo heap structure.
+
+    >>> leo = _generate_leonardo_numbers(10)
+    >>> _find_parent(0, leo)
+    -1
+    >>> _find_parent(1, leo)
+    0
+    >>> _find_parent(2, leo)
+    0
+    >>> _find_parent(5, leo)
+    2
+    """
     if index <= 0:
         return -1