Add new sorting algorithms

Author: mszula

README.md

@@ -39,6 +39,12 @@ https://github.com/user-attachments/assets/2b9674c5-c705-4a22-ba6a-474cfc11cddd
 - [Exchange Sort](https://en.wikipedia.org/wiki/Sorting_algorithm#Exchange_sort)
 - [Odd-Even Sort](https://en.wikipedia.org/wiki/Odd%E2%80%93even_sort)
 
+### 🆕 Recently Added Algorithms
+
+- [Counting Sort](https://en.wikipedia.org/wiki/Counting_sort) - Non-comparison sorting algorithm that counts occurrences of each value
+- [Comb Sort](https://en.wikipedia.org/wiki/Comb_sort) - Improved Bubble Sort variant that uses gap-based comparisons
+- [Intro Sort](https://en.wikipedia.org/wiki/Introsort) - Hybrid algorithm combining Quick Sort, Heap Sort, and Insertion Sort
+
 ## 🔍 Rationale
 
 Visual Sorting was created to explore and learn Svelte, a modern JavaScript framework. Inspired by Timo Bingmann's captivating video "The Sound of Sorting" (https://www.youtube.com/watch?v=kPRA0W1kECg), which combines sorting algorithm visualizations with sound, I wanted to develop a tool that offers a similar educational and engaging experience. Visual Sorting aims to make learning sorting algorithms both enjoyable and insightful through dynamic visuals and sounds.

src/lib/components/AlgorithmSelector.svelte

@@ -21,8 +21,17 @@
             <li>
               <button
                 class={algo.name === selectedAlgorithm?.name ? 'active' : ''}
-                on:click={click(algo)}>{algo.name}</button
+                on:click={click(algo)}
               >
+                <span class="flex items-center gap-2">
+                  {algo.name}
+                  {#if algo.badge}
+                    <span class="badge badge-primary badge-sm"
+                      >{algo.badge}</span
+                    >
+                  {/if}
+                </span>
+              </button>
             </li>
             {#if index === 2 && group > 0}
               <ArrowLeft {group} />

src/lib/components/mobile/MobileAlgorithmSelector.svelte

@@ -20,8 +20,11 @@
       {#each algos as algo, index}
         <option
           value={[group, index]}
-          selected={algo.name === selectedAlgorithm?.name}>{algo.name}</option
+          selected={algo.name === selectedAlgorithm?.name}
         >
+          {algo.name}{#if algo.badge}
+            ({algo.badge}){/if}
+        </option>
       {/each}
     {/each}
   </select>

src/lib/sort-algorithms/algorithms.ts

@@ -3,11 +3,14 @@ import { bitonicSort } from './bitonic-sort';
 import { bogoSort } from './bogo-sort';
 import { bubleSort } from './buble-sort';
 import { cocktailSort } from './cocktail-sort';
+import { combSort } from './comb-sort';
+import { countingSort } from './counting-sort';
 import { cycleSort } from './cycle-sort';
 import { exchangeSort } from './exchange-sort';
 import { gnomeSort } from './gnome-sort';
 import { heapSort } from './heap-sort';
 import { insertionSort } from './insertion-sort';
+import { introSort } from './intro-sort';
 import { mergeSort } from './merge-sort';
 import { oddEvenSort } from './odd-even-sort';
 import { pancakeSort } from './pancake-sort';
@@ -101,5 +104,20 @@ export const algorithms: AlgorithmDefinition[][] = [
       name: 'Odd Even Sort',
       function: oddEvenSort,
     },
+    {
+      name: 'Counting Sort',
+      function: countingSort,
+      badge: 'new',
+    },
+    {
+      name: 'Comb Sort',
+      function: combSort,
+      badge: 'new',
+    },
+    {
+      name: 'Intro Sort',
+      function: introSort,
+      badge: 'new',
+    },
   ],
 ];

src/lib/sort-algorithms/comb-sort.ts

@@ -0,0 +1,47 @@
+import type { SortingGenerator } from './types';
+
+/**
+ * Comb Sort Algorithm
+ *
+ * An improved version of Bubble Sort that uses a gap-based approach.
+ * It starts with a large gap and reduces the gap by a shrink factor
+ * (typically 1.3) until the gap becomes 1, at which point it becomes
+ * a regular Bubble Sort.
+ *
+ * Time Complexity: O(n²) worst case, O(n log n) average case
+ * Space Complexity: O(1)
+ *
+ * @param arr - Array of numbers to sort
+ * @yields ProgressIndicator - Visualization data for each step
+ */
+export const combSort = function* (arr: number[]): SortingGenerator {
+  const n = arr.length;
+  if (n <= 1) return;
+
+  // Initialize gap
+  let gap = n;
+  const shrinkFactor = 1.3;
+  let swapped = true;
+
+  // Continue until gap is 1 and no swaps occurred
+  while (gap > 1 || swapped) {
+    // Update gap using shrink factor
+    gap = Math.floor(gap / shrinkFactor);
+    if (gap < 1) gap = 1;
+
+    swapped = false;
+
+    // Compare elements with current gap
+    for (let i = 0; i < n - gap; i++) {
+      yield { access: [i, i + gap], sound: i + gap };
+
+      if (arr[i] > arr[i + gap]) {
+        // Swap elements
+        const temp = arr[i];
+        arr[i] = arr[i + gap];
+        arr[i + gap] = temp;
+        swapped = true;
+      }
+    }
+  }
+};

src/lib/sort-algorithms/counting-sort.ts

@@ -0,0 +1,59 @@
+import type { SortingGenerator } from './types';
+
+/**
+ * Counting Sort Algorithm
+ *
+ * A non-comparison sorting algorithm that works by counting the number of objects
+ * having distinct key values. It operates by counting the number of objects that
+ * have each distinct key value, and using arithmetic on those counts to determine
+ * the positions of each key value in the output sequence.
+ *
+ * Time Complexity: O(n + k) where n is the number of elements and k is the range of input
+ * Space Complexity: O(k)
+ *
+ * @param arr - Array of numbers to sort
+ * @yields ProgressIndicator - Visualization data for each step
+ */
+export const countingSort = function* (arr: number[]): SortingGenerator {
+  if (arr.length === 0) return;
+
+  // Find the maximum value in the array
+  let max = arr[0];
+  for (let i = 1; i < arr.length; i++) {
+    yield { access: [i], sound: i };
+    if (arr[i] > max) {
+      max = arr[i];
+    }
+  }
+
+  // Create count array with size max + 1
+  const count = new Array(max + 1).fill(0);
+
+  // Count the frequency of each element
+  for (let i = 0; i < arr.length; i++) {
+    yield { access: [i], sound: i };
+    count[arr[i]]++;
+  }
+
+  // Modify count array to store cumulative count
+  for (let i = 1; i <= max; i++) {
+    yield { access: [i - 1], sound: i - 1 };
+    count[i] += count[i - 1];
+  }
+
+  // Create output array
+  const output = new Array(arr.length);
+
+  // Build the output array
+  for (let i = arr.length - 1; i >= 0; i--) {
+    yield { access: [i], sound: i };
+    output[count[arr[i]] - 1] = arr[i];
+    count[arr[i]]--;
+  }
+
+  // Copy the output array back to the original array
+  for (let i = 0; i < arr.length; i++) {
+    yield { access: [i], sound: i };
+    arr[i] = output[i];
+  }
+};

src/lib/sort-algorithms/intro-sort.ts

@@ -0,0 +1,159 @@
+import type { SortingGenerator } from './types';
+
+/**
+ * Intro Sort (Introsort) Algorithm
+ *
+ * A hybrid sorting algorithm that combines Quick Sort, Heap Sort, and Insertion Sort.
+ * It starts with Quick Sort, switches to Heap Sort when the recursion depth becomes
+ * too deep, and uses Insertion Sort for small subarrays.
+ *
+ * Time Complexity: O(n log n) guaranteed worst case
+ * Space Complexity: O(log n)
+ *
+ * @param arr - Array of numbers to sort
+ * @yields ProgressIndicator - Visualization data for each step
+ */
+export const introSort = function* (arr: number[]): SortingGenerator {
+  const n = arr.length;
+  if (n <= 1) return;
+
+  // Calculate maximum recursion depth (2 * log2(n))
+  const maxDepth = Math.floor(2 * Math.log2(n));
+
+  yield* introSortRecursive(arr, 0, n - 1, maxDepth);
+};
+
+function* introSortRecursive(
+  arr: number[],
+  low: number,
+  high: number,
+  depthLimit: number
+): SortingGenerator {
+  const size = high - low + 1;
+
+  // Use insertion sort for small arrays
+  if (size < 16) {
+    yield* insertionSort(arr, low, high);
+    return;
+  }
+
+  // If depth limit reached, switch to heap sort
+  if (depthLimit === 0) {
+    yield* heapSortRange(arr, low, high);
+    return;
+  }
+
+  // Use quick sort for larger arrays
+  const pivotIndex = yield* partition(arr, low, high);
+
+  // Recursively sort the two partitions
+  yield* introSortRecursive(arr, low, pivotIndex - 1, depthLimit - 1);
+  yield* introSortRecursive(arr, pivotIndex + 1, high, depthLimit - 1);
+}
+
+function* partition(
+  arr: number[],
+  low: number,
+  high: number
+): Generator<ProgressIndicator, number, unknown> {
+  // Choose middle element as pivot
+  const pivotIndex = Math.floor((low + high) / 2);
+  const pivot = arr[pivotIndex];
+
+  // Move pivot to end
+  [arr[pivotIndex], arr[high]] = [arr[high], arr[pivotIndex]];
+  yield { access: [pivotIndex, high], sound: high };
+
+  let i = low - 1;
+
+  for (let j = low; j < high; j++) {
+    yield { access: [j], sound: j };
+
+    if (arr[j] <= pivot) {
+      i++;
+      if (i !== j) {
+        [arr[i], arr[j]] = [arr[j], arr[i]];
+        yield { access: [i, j], sound: j };
+      }
+    }
+  }
+
+  // Move pivot to its correct position
+  [arr[i + 1], arr[high]] = [arr[high], arr[i + 1]];
+  yield { access: [i + 1, high], sound: high };
+
+  return i + 1;
+}
+
+function* insertionSort(
+  arr: number[],
+  low: number,
+  high: number
+): SortingGenerator {
+  for (let i = low + 1; i <= high; i++) {
+    const key = arr[i];
+    let j = i - 1;
+
+    yield { access: [i], sound: i };
+
+    while (j >= low && arr[j] > key) {
+      yield { access: [j, j + 1], sound: j + 1 };
+      arr[j + 1] = arr[j];
+      j--;
+    }
+
+    if (j + 1 !== i) {
+      arr[j + 1] = key;
+      yield { access: [j + 1], sound: j + 1 };
+    }
+  }
+}
+
+function* heapSortRange(
+  arr: number[],
+  low: number,
+  high: number
+): SortingGenerator {
+  const n = high - low + 1;
+
+  // Build max heap
+  for (let i = Math.floor(n / 2) - 1; i >= 0; i--) {
+    yield* heapify(arr, low, n, i);
+  }
+
+  // Extract elements from heap one by one
+  for (let i = n - 1; i > 0; i--) {
+    // Move current root to end
+    [arr[low], arr[low + i]] = [arr[low + i], arr[low]];
+    yield { access: [low, low + i], sound: low + i };
+
+    // Call heapify on the reduced heap
+    yield* heapify(arr, low, i, 0);
+  }
+}
+
+function* heapify(
+  arr: number[],
+  low: number,
+  n: number,
+  i: number
+): SortingGenerator {
+  let largest = i;
+  const left = 2 * i + 1;
+  const right = 2 * i + 2;
+
+  if (left < n && arr[low + left] > arr[low + largest]) {
+    largest = left;
+  }
+
+  if (right < n && arr[low + right] > arr[low + largest]) {
+    largest = right;
+  }
+
+  if (largest !== i) {
+    [arr[low + i], arr[low + largest]] = [arr[low + largest], arr[low + i]];
+    yield { access: [low + i, low + largest], sound: low + largest };
+
+    yield* heapify(arr, low, n, largest);
+  }
+}

src/lib/sort-algorithms/types.ts

@@ -13,4 +13,5 @@ export type AlgorithmDefinition = {
   name: string;
   function: (arr: number[]) => SortingGenerator;
   arraySizeComponent?: typeof SvelteComponent<{ size: number }>;
+  badge?: string;
 };