Add: Merge Sort and Heap Sort to Multi-Algorithm Sorting Visualizer

ruhelamahi7-code · ruhelamahi7-code · commit d9493044b028 · 2026-07-20T12:36:27.000+05:30
diff --git a/math/Heap-Sort/Heap-Sort.py b/math/Heap-Sort/Heap-Sort.py
@@ -0,0 +1,113 @@
+import sys
+import os
+
+# Add project root to sys.path
+if "__file__" in globals():
+    sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")))
+else:
+    sys.path.append(os.path.abspath(os.getcwd()))
+
+from utils.validation import get_choice, get_int_list
+
+
+def _sift_down(arr: list[int], start: int, end: int, reverse: bool) -> None:
+    """Restores the heap property for the subtree rooted at `start`.
+
+    Args:
+        arr: The list being heapified (mutated in place).
+        start: Index of the subtree root to sift down from.
+        end: Last valid index of the active heap region.
+        reverse: If True, maintains a min-heap (for descending sort).
+                 Otherwise, maintains a max-heap (for ascending sort).
+    """
+    root = start
+
+    while True:
+        child = 2 * root + 1
+        if child > end:
+            break
+
+        # Pick the child that should be closer to the root
+        if child + 1 <= end:
+            if not reverse and arr[child] < arr[child + 1]:
+                child += 1
+            elif reverse and arr[child] > arr[child + 1]:
+                child += 1
+
+        should_swap = (not reverse and arr[root] < arr[child]) or (reverse and arr[root] > arr[child])
+
+        if should_swap:
+            arr[root], arr[child] = arr[child], arr[root]
+            root = child
+        else:
+            break
+
+
+def heap_sort(arr: list[int], reverse: bool = False) -> list[int]:
+    """Sorts a list of integers using the Heap Sort algorithm.
+
+    Args:
+        arr: The list of integers to sort.
+        reverse: If True, sorts in descending order. Otherwise, ascending.
+
+    Returns:
+        A new sorted list.
+    """
+    result = arr.copy()
+    n = len(result)
+
+    # Phase 1: Build a max-heap (ascending) or min-heap (descending)
+    for start in range(n // 2 - 1, -1, -1):
+        _sift_down(result, start, n - 1, reverse)
+
+    # Phase 2: Repeatedly extract the root and shrink the heap
+    for end in range(n - 1, 0, -1):
+        result[0], result[end] = result[end], result[0]
+        _sift_down(result, 0, end - 1, reverse)
+
+    return result
+
+
+def main() -> None:
+    print("=" * 50)
+    print("🏔️  HEAP SORT INTERACTIVE TOOL 🏔️")
+    print("=" * 50)
+    print("Sort a list of numbers in Ascending or Descending order.\n")
+
+    while True:
+        print("=" * 50)
+
+        arr = get_int_list(
+            prompt="➡️  Enter numbers to sort separated by spaces (e.g., 64 34 25): ",
+            error_empty="❌ Error: Input cannot be empty!",
+            error_invalid="❌ Error: Please enter valid integers only."
+        )
+
+        print("\nChoose sorting order:")
+        print("1️⃣  Ascending")
+        print("2️⃣  Descending")
+
+        order_choice = get_choice(
+            prompt="🎯 Enter your choice (1 or 2): ",
+            choices=["1", "2"],
+            error_invalid="❌ Invalid sorting choice! Please select 1 or 2."
+        )
+
+        reverse = (order_choice == "2")
+
+        sorted_arr = heap_sort(arr, reverse)
+
+        print(f"\n📊 Original list: {arr}")
+        if reverse:
+            print(f"✅ Sorted list (Descending): {sorted_arr}")
+        else:
+            print(f"✅ Sorted list (Ascending): {sorted_arr}")
+
+        again = input("\n🔄 Do you want to sort another list? (y/n): ").strip().lower()
+        if again != 'y':
+            print("\n👋 Thanks for using Heap Sort Tool! Goodbye!\n")
+            break
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/test_heap_sort.py b/tests/test_heap_sort.py
@@ -0,0 +1,77 @@
+import unittest
+from unittest.mock import patch
+import io
+import os
+import importlib.util
+
+# Absolute path to Heap-Sort.py
+file_path = os.path.join(
+    os.path.dirname(__file__), "..",
+    "math", "Heap-Sort", "Heap-Sort.py"
+)
+file_path = os.path.abspath(file_path)
+
+# Load module dynamically
+spec = importlib.util.spec_from_file_location("heap_sort_module", file_path)
+heap_sort_module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(heap_sort_module)
+
+heap_sort = heap_sort_module.heap_sort
+main = heap_sort_module.main
+
+
+class TestHeapSort(unittest.TestCase):
+
+    def test_heap_sort_ascending(self):
+        self.assertEqual(heap_sort([64, 34, 25, 12, 22, 11, 90]), [11, 12, 22, 25, 34, 64, 90])
+        self.assertEqual(heap_sort([5, 1, 4, 2, 8]), [1, 2, 4, 5, 8])
+
+    def test_heap_sort_descending(self):
+        self.assertEqual(heap_sort([64, 34, 25, 12, 22, 11, 90], reverse=True), [90, 64, 34, 25, 22, 12, 11])
+        self.assertEqual(heap_sort([5, 1, 4, 2, 8], reverse=True), [8, 5, 4, 2, 1])
+
+    def test_heap_sort_empty_and_single_item(self):
+        self.assertEqual(heap_sort([]), [])
+        self.assertEqual(heap_sort([42]), [42])
+
+    def test_heap_sort_negative_integers(self):
+        self.assertEqual(heap_sort([-5, -1, -10, 0, 5]), [-10, -5, -1, 0, 5])
+        self.assertEqual(heap_sort([-5, -1, -10, 0, 5], reverse=True), [5, 0, -1, -5, -10])
+
+    def test_heap_sort_already_sorted(self):
+        self.assertEqual(heap_sort([1, 2, 3, 4, 5]), [1, 2, 3, 4, 5])
+        self.assertEqual(heap_sort([5, 4, 3, 2, 1], reverse=True), [5, 4, 3, 2, 1])
+
+    def test_heap_sort_with_duplicates(self):
+        self.assertEqual(heap_sort([5, 3, 8, 3, 9, 1, 5]), [1, 3, 3, 5, 5, 8, 9])
+
+    def test_heap_sort_does_not_mutate_original(self):
+        original = [5, 3, 1, 4, 2]
+        original_copy = original.copy()
+        heap_sort(original)
+        self.assertEqual(original, original_copy)
+
+    @patch('builtins.input')
+    @patch('sys.stdout', new_callable=io.StringIO)
+    def test_main_flow_ascending(self, mock_stdout, mock_input):
+        mock_input.side_effect = ["64 34 25", "1", "n"]
+        main()
+        output = mock_stdout.getvalue()
+        self.assertIn("Original list: [64, 34, 25]", output)
+        self.assertIn("Sorted list (Ascending): [25, 34, 64]", output)
+
+    @patch('builtins.input')
+    @patch('sys.stdout', new_callable=io.StringIO)
+    def test_main_flow_invalid_inputs(self, mock_stdout, mock_input):
+        mock_input.side_effect = ["", "64 abc 25", "64 34 25", "3", "64 34 25", "1", "y", "12 11", "2", "n"]
+        main()
+        output = mock_stdout.getvalue()
+        self.assertIn("Error: Input cannot be empty!", output)
+        self.assertIn("Error: Please enter valid integers only.", output)
+        self.assertIn("Invalid sorting choice! Please select 1 or 2.", output)
+        self.assertIn("Sorted list (Ascending): [25, 34, 64]", output)
+        self.assertIn("Sorted list (Descending): [12, 11]", output)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/web-app/js/projects/sorting-visualizer.js b/web-app/js/projects/sorting-visualizer.js
@@ -12,6 +12,8 @@ function getSortingVisualizerHTML() {
                             <option value="selection">Selection Sort</option>
                             <option value="insertion">Insertion Sort</option>
                             <option value="quick">Quick Sort</option>
+                            <option value="merge">Merge Sort</option>
+                            <option value="heap">Heap Sort</option>
                         </select>
                     </div>
                     
@@ -289,7 +291,9 @@ function initSortingVisualizer() {
         bubble: { time: "O(N²)", space: "O(1)" },
         selection: { time: "O(N²)", space: "O(1)" },
         insertion: { time: "O(N²)", space: "O(1)" },
-        quick: { time: "O(N log N) avg / O(N²) worst", space: "O(log N)" }
+        quick: { time: "O(N log N) avg / O(N²) worst", space: "O(log N)" },
+        merge: { time: "O(N log N)", space: "O(N)" },
+        heap: { time: "O(N log N)", space: "O(1)" }
     };
 
     // Update complexities when algorithm changes
@@ -507,6 +511,121 @@ function initSortingVisualizer() {
         renderBars(arr, [], [], Array.from({length: arr.length}, (_, idx) => idx));
     }
 
+    async function mergeSortVisual(arr) {
+        const sortedIndices = [];
+
+        async function mergeHelper(left, right) {
+            if (left >= right) {
+                if (!sortedIndices.includes(left)) sortedIndices.push(left);
+                return;
+            }
+            if (cancelSorting) return;
+
+            const mid = Math.floor((left + right) / 2);
+            await mergeHelper(left, mid);
+            await mergeHelper(mid + 1, right);
+            if (cancelSorting) return;
+
+            const leftArr = arr.slice(left, mid + 1);
+            const rightArr = arr.slice(mid + 1, right + 1);
+            let i = 0, j = 0, k = left;
+            const range = Array.from({ length: right - left + 1 }, (_, idx) => left + idx);
+
+            while (i < leftArr.length && j < rightArr.length) {
+                if (cancelSorting) return;
+                comparisons++;
+                renderBars(arr, range, [], sortedIndices);
+                await sleep(delay());
+
+                const shouldPickLeft = isAscending ? leftArr[i] <= rightArr[j] : leftArr[i] >= rightArr[j];
+                arr[k] = shouldPickLeft ? leftArr[i++] : rightArr[j++];
+                swaps++;
+                renderBars(arr, [], [k], sortedIndices);
+                await sleep(delay());
+                k++;
+            }
+            while (i < leftArr.length) {
+                arr[k] = leftArr[i++];
+                swaps++;
+                renderBars(arr, [], [k], sortedIndices);
+                await sleep(delay());
+                k++;
+            }
+            while (j < rightArr.length) {
+                arr[k] = rightArr[j++];
+                swaps++;
+                renderBars(arr, [], [k], sortedIndices);
+                await sleep(delay());
+                k++;
+            }
+
+            for (let idx = left; idx <= right; idx++) {
+                if (!sortedIndices.includes(idx)) sortedIndices.push(idx);
+            }
+            renderBars(arr, [], [], sortedIndices);
+            await sleep(delay());
+        }
+
+        await mergeHelper(0, arr.length - 1);
+        renderBars(arr, [], [], Array.from({ length: arr.length }, (_, idx) => idx));
+    }
+
+    async function heapSortVisual(arr) {
+        const n = arr.length;
+        const sortedIndices = [];
+
+        async function siftDown(root, end) {
+            while (true) {
+                if (cancelSorting) return;
+                let child = 2 * root + 1;
+                if (child > end) break;
+
+                comparisons++;
+                renderBars(arr, [root, child], [], sortedIndices);
+                await sleep(delay());
+
+                if (child + 1 <= end) {
+                    comparisons++;
+                    renderBars(arr, [root, child, child + 1], [], sortedIndices);
+                    await sleep(delay());
+                    const rightIsNext = isAscending ? arr[child + 1] > arr[child] : arr[child + 1] < arr[child];
+                    if (rightIsNext) child++;
+                }
+
+                const shouldSwap = isAscending ? arr[root] < arr[child] : arr[root] > arr[child];
+                if (shouldSwap) {
+                    swaps++;
+                    renderBars(arr, [], [root, child], sortedIndices);
+                    await sleep(delay());
+                    [arr[root], arr[child]] = [arr[child], arr[root]];
+                    root = child;
+                } else {
+                    break;
+                }
+            }
+        }
+
+        for (let start = Math.floor(n / 2) - 1; start >= 0; start--) {
+            if (cancelSorting) return;
+            await siftDown(start, n - 1);
+        }
+
+        for (let end = n - 1; end > 0; end--) {
+            if (cancelSorting) return;
+            swaps++;
+            renderBars(arr, [], [0, end], sortedIndices);
+            await sleep(delay());
+            [arr[0], arr[end]] = [arr[end], arr[0]];
+            sortedIndices.push(end);
+            renderBars(arr, [], [], sortedIndices);
+            await sleep(delay());
+            await siftDown(0, end - 1);
+        }
+
+        if (!sortedIndices.includes(0)) sortedIndices.push(0);
+        renderBars(arr, [], [], sortedIndices);
+    }
+
     randomSort.addEventListener('click', () => {
         if (isSorting) return;
         generateRandomArray();
@@ -563,6 +682,10 @@ function initSortingVisualizer() {
             await insertionSort(workingArr);
         } else if (algo === 'quick') {
             await quickSortVisual(workingArr);
+        } else if (algo === 'merge') {
+            await mergeSortVisual(workingArr);
+        } else if (algo === 'heap') {
+            await heapSortVisual(workingArr);
         }
 
         if (cancelSorting) {
@@ -590,4 +713,4 @@ function initSortingVisualizer() {
 
     // Initial render
     generateRandomArray();
-}
+}
