Added implementations for core sorting algorithms

Introduces the following sorting algorithms into the `algorithms/` directory:
- Selection Sort
- Insertion Sort
- Quick Sort
- Heap Sort
- Radix Sort
- Merge Sort
- Shell Sort

Author: Cherecho

algorithms/heap_sort.py

@@ -0,0 +1,58 @@
+def heap_sort(array, update_callback):
+    def heapify(n, i, arr_copy):  # Pass arr_copy for visualization consistency
+        largest = i
+        l = 2 * i + 1
+        r = 2 * i + 2
+
+        # Highlight the root being considered for heapify
+        update_callback(arr_copy, highlight_indices=[i], moving_index=None)
+
+        # See if left child exists and is greater than root
+        if l < n:
+            # Highlight comparison
+            update_callback(arr_copy, highlight_indices=[i, l], moving_index=l)
+            if array[l] > array[largest]:
+                largest = l
+
+        # See if right child exists and is greater than largest so far
+        if r < n:
+            # Highlight comparison
+            update_callback(arr_copy, highlight_indices=[i, largest, r], moving_index=r)
+            if array[r] > array[largest]:
+                largest = r
+
+        # Change root, if needed
+        if largest != i:
+            array[i], array[largest] = array[largest], array[i]
+            # Highlight the swap during heapify
+            arr_copy[:] = array  # Update visualization copy
+            update_callback(
+                arr_copy, highlight_indices=[i, largest], moving_index=largest
+            )
+            # Heapify the root.
+            heapify(n, largest, arr_copy)
+
+    n = len(array)
+    vis_array = list(array)  # Use a copy for consistent visualization during heapify
+
+    # Build a maxheap.
+    # Since last parent will be at ((n//2)-1) we can start at that location.
+    for i in range(n // 2 - 1, -1, -1):
+        heapify(n, i, vis_array)
+
+    # One by one extract elements
+    for i in range(n - 1, 0, -1):
+        # Move current root to end
+        array[i], array[0] = array[0], array[i]
+        # Highlight the swap (moving max element to sorted position)
+        vis_array[:] = array  # Update visualization copy
+        update_callback(vis_array, highlight_indices=[0, i], moving_index=i)
+
+        # call max heapify on the reduced heap
+        heapify(i, 0, vis_array)
+
+    update_callback(array)  # Final update before sweep
+
+    # Final sweep animation
+    for i in range(n):
+        update_callback(array, moving_index=i, end=True, sweep=True)

algorithms/insertion_sort.py

@@ -0,0 +1,24 @@
+def insertion_sort(array, update_callback):
+    n = len(array)
+    for i in range(1, n):
+        key = array[i]
+        j = i - 1
+        # Highlight the key element being considered
+        update_callback(array, highlight_indices=[i], moving_index=i)
+
+        # Move elements of array[0..i-1], that are greater than key,
+        # to one position ahead of their current position
+        while j >= 0 and key < array[j]:
+            array[j + 1] = array[j]
+            # Highlight comparison and the element being shifted
+            update_callback(array, highlight_indices=[j, i], moving_index=j + 1)
+            j -= 1
+        array[j + 1] = key
+        # Highlight the final position where the key was inserted
+        update_callback(array, highlight_indices=[j + 1], moving_index=j + 1)
+
+    update_callback(array)  # Final update before sweep
+
+    # Final sweep animation
+    for i in range(n):
+        update_callback(array, moving_index=i, end=True, sweep=True)

algorithms/merge_sort.py

@@ -0,0 +1,61 @@
+def merge_sort(array, update_callback):
+    def merge_sort_recursive(arr, temp, left_start, right_end):
+        if left_start >= right_end:
+            return
+
+        middle = (left_start + right_end) // 2
+        merge_sort_recursive(arr, temp, left_start, middle)
+        merge_sort_recursive(arr, temp, middle + 1, right_end)
+        merge(arr, temp, left_start, right_end)
+
+    def merge(arr, temp, left_start, right_end):
+        left_end = (right_end + left_start) // 2
+        right_start = left_end + 1
+        size = right_end - left_start + 1
+
+        left = left_start
+        right = right_start
+        index = left_start
+
+        highlight = list(range(left_start, right_end + 1))
+
+        while left <= left_end and right <= right_end:
+            # Highlight elements being compared
+            update_callback(arr, highlight_indices=[left, right], moving_index=index)
+            if arr[left] <= arr[right]:
+                temp[index] = arr[left]
+                left += 1
+            else:
+                temp[index] = arr[right]
+                right += 1
+            index += 1
+
+        # Copy remaining elements from left half
+        while left <= left_end:
+            update_callback(arr, highlight_indices=[left], moving_index=index)
+            temp[index] = arr[left]
+            left += 1
+            index += 1
+
+        # Copy remaining elements from right half
+        while right <= right_end:
+            update_callback(arr, highlight_indices=[right], moving_index=index)
+            temp[index] = arr[right]
+            right += 1
+            index += 1
+
+        # Copy sorted elements back to original array
+        for i in range(left_start, right_end + 1):
+            arr[i] = temp[i]
+            # Show the placement in the original array
+            update_callback(arr, highlight_indices=[i], moving_index=i)
+
+    n = len(array)
+    temp_array = [0] * n
+    merge_sort_recursive(array, temp_array, 0, n - 1)
+
+    update_callback(array)  # Final update before sweep
+
+    # Final sweep animation
+    for i in range(n):
+        update_callback(array, moving_index=i, end=True, sweep=True)

algorithms/quick_sort.py

@@ -0,0 +1,36 @@
+def quick_sort(array, update_callback):
+    def partition(low, high):
+        pivot = array[high]
+        # Highlight the pivot element
+        update_callback(array, highlight_indices=[high], moving_index=None)
+        i = low - 1
+        for j in range(low, high):
+            # Highlight elements being compared
+            update_callback(array, highlight_indices=[i + 1, j, high], moving_index=j)
+            if array[j] < pivot:
+                i += 1
+                array[i], array[j] = array[j], array[i]
+                # Highlight the swap
+                update_callback(array, highlight_indices=[i, j, high], moving_index=j)
+
+        # Place pivot in correct position
+        array[i + 1], array[high] = array[high], array[i + 1]
+        # Highlight the pivot's final position for this partition
+        update_callback(array, highlight_indices=[i + 1], moving_index=i + 1)
+        return i + 1
+
+    def quick_sort_recursive(low, high):
+        if low < high:
+            # pi is partitioning index, array[p] is now at right place
+            pi = partition(low, high)
+
+            # Separately sort elements before partition and after partition
+            quick_sort_recursive(low, pi - 1)
+            quick_sort_recursive(pi + 1, high)
+
+    quick_sort_recursive(0, len(array) - 1)
+    update_callback(array)  # Final update before sweep
+
+    # Final sweep animation
+    for i in range(len(array)):
+        update_callback(array, moving_index=i, end=True, sweep=True)

algorithms/radix_sort.py

@@ -0,0 +1,50 @@
+def radix_sort(array, update_callback):
+    def counting_sort(array, exp):
+        n = len(array)
+        output = [0] * n
+        count = [0] * 10
+
+        # Store count of occurrences in count[]
+        for i in range(n):
+            index = array[i] // exp
+            count[index % 10] += 1
+            # Highlight element being read
+            update_callback(array, highlight_indices=[i], moving_index=None)
+
+        # Change count[i] so that count[i] now contains actual
+        # position of this digit in output[]
+        for i in range(1, 10):
+            count[i] += count[i - 1]
+
+        # Build the output array
+        i = n - 1
+        while i >= 0:
+            index = array[i] // exp
+            output_idx = count[index % 10] - 1
+            output[output_idx] = array[i]
+            count[index % 10] -= 1
+            # Highlight element being placed
+            update_callback(array, highlight_indices=[i], moving_index=output_idx)
+            i -= 1
+
+        # Copy the output array to array[], so that array[] now
+        # contains sorted numbers according to current digit
+        for i in range(n):
+            array[i] = output[i]
+            # Show the array after this pass - highlight the element just placed
+            update_callback(array, highlight_indices=[], moving_index=i)
+
+    if not array:
+        return  # Handle empty array
+
+    max_element = max(array) if array else 0
+    exp = 1
+    while max_element // exp > 0:
+        counting_sort(array, exp)
+        exp *= 10
+
+    update_callback(array)  # Final update before sweep
+
+    # Final sweep animation
+    for i in range(len(array)):
+        update_callback(array, moving_index=i, end=True, sweep=True)

algorithms/selection_sort.py

@@ -0,0 +1,26 @@
+def selection_sort(array, update_callback):
+    n = len(array)
+    for i in range(n):
+        # Find the minimum element in remaining unsorted array
+        min_idx = i
+        # Highlight the start of the unsorted section
+        update_callback(array, highlight_indices=[i], moving_index=None)
+
+        for j in range(i + 1, n):
+            # Highlight current minimum and element being compared
+            update_callback(array, highlight_indices=[i, min_idx], moving_index=j)
+            if array[j] < array[min_idx]:
+                min_idx = j
+                # Highlight the new minimum found
+                update_callback(array, highlight_indices=[i, min_idx], moving_index=j)
+
+        # Swap the found minimum element with the first element
+        array[i], array[min_idx] = array[min_idx], array[i]
+        # Highlight the swap into the sorted position
+        update_callback(array, highlight_indices=[i], moving_index=min_idx)
+
+    update_callback(array)  # Final update before sweep
+
+    # Final sweep animation
+    for i in range(n):
+        update_callback(array, moving_index=i, end=True, sweep=True)

algorithms/shell_sort.py

@@ -0,0 +1,39 @@
+def shell_sort(array, update_callback):
+    n = len(array)
+    # Start with a large gap, then reduce the gap
+    # Using Knuth's sequence: h = h * 3 + 1 -> ..., 40, 13, 4, 1
+    gap = 1
+    while gap < n / 3:
+        gap = gap * 3 + 1
+
+    while gap > 0:
+        # Do a gapped insertion sort for this gap size.
+        # The first gap elements a[0..gap-1] are already in gapped order
+        # keep adding one more element until the entire array is gap sorted
+        for i in range(gap, n):
+            # add a[i] to the elements that have been gap sorted
+            # save a[i] in temp and make a hole at position i
+            temp = array[i]
+
+            # shift earlier gap-sorted elements up until the correct location for a[i] is found
+            j = i
+            while j >= gap and array[j - gap] > temp:
+                array[j] = array[j - gap]
+                # Highlight comparison and movement
+                update_callback(array, highlight_indices=[j, j - gap], moving_index=j)
+                j -= gap
+
+            # put temp (the original a[i]) in its correct location
+            array[j] = temp
+            update_callback(
+                array, highlight_indices=[i], moving_index=j
+            )  # Show final placement
+
+        # Reduce the gap
+        gap = gap // 3  # Integer division is fine here
+
+    update_callback(array)  # Final update before sweep
+
+    # Final sweep animation
+    for i in range(n):
+        update_callback(array, moving_index=i, end=True, sweep=True)