import time
import random
import sys

# ---------------------------------------------------------
# Student Info [cite: 15-18]
# ---------------------------------------------------------
# Student Name: 
# ID: 
# Group#: 
# ---------------------------------------------------------

# ==========================================
# 1. Quicksort Implementation [cite: 53-73]
# ==========================================
def partition(arr, left, right):
    pivot = arr[left] # Choose first element as pivot [cite: 62]
    i = left
    
    for j in range(left + 1, right + 1):
        if arr[j] < pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
            
    # Place pivot in correct position
    arr[left], arr[i] = arr[i], arr[left]
    return i

def quicksort(arr, left = None, right = None):
    if left is None: 
        left = 0

    if right is None: 
        right = len(arr) - 1

    if left < right:
        p = partition(arr, left, right)
        quicksort(arr, left, p - 1)
        quicksort(arr, p + 1, right)

    return arr

def heapify(arr, n, i):
    largest = i
    left = 2 * i + 1
    right = 2 * i + 2
    
    # Check left child
    if left < n and arr[left] > arr[largest]:
        largest = left
        
    # Check right child
    if right < n and arr[right] > arr[largest]:
        largest = right
        
    # Swap and continue heapifying if root is not largest
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

def heapsort(arr):
    n = len(arr)
    
    # Build a Max Heap
    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)
        
    # Extract elements one by one
    for end in range(n - 1, 0, -1):
        arr[0], arr[end] = arr[end], arr[0]
        heapify(arr, end, 0)

    return arr

def merge(left, right):
    result = []
    i = j = 0
    
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
            
    result.extend(left[i:])
    result.extend(right[j:])
    return result

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
        
    mid = len(arr) // 2
    left_half = arr[:mid]
    right_half = arr[mid:]
    
    sorted_left = merge_sort(left_half)
    sorted_right = merge_sort(right_half)
    
    return merge(sorted_left, sorted_right)

def selection_sort(arr):
    n = len(arr)
    for i in range(n):
        min_index = i
        for j in range(i + 1, n):
            if arr[j] < arr[min_index]:
                min_index = j
        arr[i], arr[min_index] = arr[min_index], arr[i]

    return arr

def compare_sorts(arr: list):

    algorithms = [quicksort, heapsort, merge_sort, selection_sort]

    for algorithm in algorithms:
        copy = arr.copy()
        start = time.time()
        sorted = algorithm(copy)
        end = time.time()

        print(f"{algorithm.__name__:<15} {(end - start) * 1000:<10.5f} {sorted}")


a = [12, 5, 9, 1, 14, 3, 7]
compare_sorts(a)

التتبع كامل: https://claude.ai/public/artifacts/d5647787-630d-4c22-b6d9-c67d697eac36