sorting-algorithms

name	sorting-algorithms
description	Complete sorting algorithm implementations including quick sort, merge sort, and binary search with complexity analysis and production-ready code.
sasmp_version	1.3.0
bonded_agent	05-sorting-searching
bond_type	PRIMARY_BOND
atomic_responsibility	sorting_algorithm_execution
version	2.0.0
parameter_validation	{"strict":true,"rules":[{"name":"arr","type":"list","required":true},{"name":"target","type":"any","required":false}]}
retry_logic	{"max_attempts":3,"backoff_ms":[100,200,400],"retryable_errors":["stack_overflow","timeout"]}
logging_hooks	{"on_start":true,"on_complete":true,"on_error":true,"log_format":"[SRT-SKILL] {timestamp} | {operation} | {status}"}
complexity_annotations	{"merge_sort":{"time":"O(n log n)","space":"O(n)"},"quick_sort":{"time":"O(n log n) avg, O(n²) worst","space":"O(log n)"},"binary_search":{"time":"O(log n)","space":"O(1)"}}

Sorting Algorithms Skill

Atomic Responsibility: Execute sorting and searching algorithms efficiently.

Merge Sort - O(n log n) Guaranteed

from typing import List

def merge_sort(arr: List[int]) -> List[int]:
    """
    Stable, divide-and-conquer sorting.

    Time: O(n log n), Space: O(n)
    Use for: Linked lists, when stability needed
    """
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])

    return merge(left, right)


def merge(left: List[int], right: List[int]) -> List[int]:
    result = []
    i = j = 0

    while i < len(left) and j < len(right):
        if left[i] <= right[j]:  # <= for stability
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    result.extend(left[i:])
    result.extend(right[j:])
    return result

Quick Sort - O(n log n) Average

import random

def quick_sort(arr: List[], low:  = , high:  = ) -> :
    
     high  :
        high = (arr) - 

     low < high:
        pivot_idx = partition(arr, low, high)
        quick_sort(arr, low, pivot_idx - )
        quick_sort(arr, pivot_idx + , high)


 () -> :
    
    rand_idx = random.randint(low, high)
    arr[rand_idx], arr[high] = arr[high], arr[rand_idx]

    pivot = arr[high]
    i = low - 

     j  (low, high):
         arr[j] <= pivot:
            i += 
            arr[i], arr[j] = arr[j], arr[i]

    arr[i + ], arr[high] = arr[high], arr[i + ]
     i +