feat: heap sort

Author: Oskar Widmark

src/Options.tsx

@@ -20,6 +20,8 @@ const getAlgorithmOptionFields = (
       return ['base'];
     case SortName.CombSort:
       return ['shrinkFactor'];
+    case SortName.Heapsort:
+      return ['heapType'];
     default:
       return [];
   }
@@ -40,6 +42,7 @@ const ALGORITHM_OPTION_LABELS: Record<keyof AlgorithmOptions, string> = {
   type: 'Type',
   base: 'Base',
   shrinkFactor: 'Shrink Factor',
+  heapType: 'Heap Type',
 };
 
 const ALGORITHM_OPTION_TEXT_FIELD_TYPES: Record<
@@ -49,6 +52,7 @@ const ALGORITHM_OPTION_TEXT_FIELD_TYPES: Record<
   type: 'select',
   base: 'number',
   shrinkFactor: 'number',
+  heapType: 'select',
 };
 
 const ALGORITHM_OPTION_VALUES: Record<
@@ -58,6 +62,7 @@ const ALGORITHM_OPTION_VALUES: Record<
   type: ['iterative', 'recursive'],
   base: [],
   shrinkFactor: [],
+  heapType: ['max', 'min'],
 };
 
 const ALGORITHM_OPTION_VALUE_LABELS: Record<
@@ -66,6 +71,8 @@ const ALGORITHM_OPTION_VALUE_LABELS: Record<
 > = {
   iterative: 'Iterative',
   recursive: 'Recursive',
+  max: 'Max Heap',
+  min: 'Min Heap',
 };
 
 interface OptionsProps {

src/constants.ts

@@ -14,6 +14,7 @@ export const DEFAULT_ALGORITHM_OPTIONS: AlgorithmOptions = {
   type: 'iterative',
   base: 4,
   shrinkFactor: 1.3,
+  heapType: 'max',
 };
 export const DEFAULT_SOUND_VOLUME = 50;
 export const DEFAULT_SOUND_TYPE = 'triangle';

src/sorting-algorithms.ts

@@ -22,6 +22,7 @@ export class SortingAlgorithms {
     [SortName.BitonicSort]: this.bitonicSort,
     [SortName.BullySort]: this.bullySort,
     [SortName.AverageSort]: this.averageSort,
+    [SortName.Heapsort]: this.heapsort,
     // 'Bully Sort 2': this.bullySort2,
   };
 
@@ -572,4 +573,66 @@ public async   mergeSort(arr, start, end){
     await this._averageSort(arr, start, mid);
     await this._averageSort(arr, mid, end);
   }
+
+  public async heapsort(arr: SortValue[], options: AlgorithmOptions) {
+    switch (options.heapType) {
+      case 'min':
+        return await this.minHeapsort(arr);
+      case 'max':
+        return await this.maxHeapsort(arr);
+    }
+  }
+
+  private async minHeapsort(arr: SortValue[]) {
+    for (let i = Math.ceil(arr.length / 2) + 1; i < arr.length; i++) {
+      await this.minHeapify(arr, 0, i);
+    }
+    for (let i = 0; i < arr.length; i++) {
+      await this.drawAndSwap(arr, arr.length - 1, i);
+      await this.minHeapify(arr, i, arr.length - 1);
+    }
+  }
+
+  private async maxHeapsort(arr: SortValue[]) {
+    for (let i = Math.floor(arr.length / 2) - 1; i >= 0; i--) {
+      await this.maxHeapify(arr, arr.length, i);
+    }
+    for (let i = arr.length - 1; i > 0; i--) {
+      await this.drawAndSwap(arr, 0, i);
+      await this.maxHeapify(arr, i, 0);
+    }
+  }
+
+  // This a reversed heap, with the smallest element at the last index
+  private async minHeapify(arr: SortValue[], n: number, i: number) {
+    let smallestIndex = i;
+    const left = arr.length - 1 - (2 * (arr.length - 1 - i) + 2);
+    const right = arr.length - 1 - (2 * (arr.length - 1 - i) + 1);
+    if (left > n && (await this.compare(arr, smallestIndex, '>', left))) {
+      smallestIndex = left;
+    }
+    if (right > n && (await this.compare(arr, smallestIndex, '>', right))) {
+      smallestIndex = right;
+    }
+    if (smallestIndex !== i) {
+      await this.drawAndSwap(arr, i, smallestIndex);
+      await this.minHeapify(arr, n, smallestIndex);
+    }
+  }
+
+  private async maxHeapify(arr: SortValue[], n: number, i: number) {
+    let largestIndex = i;
+    const left = 2 * i + 1;
+    const right = 2 * i + 2;
+    if (left < n && (await this.compare(arr, left, '>', largestIndex))) {
+      largestIndex = left;
+    }
+    if (right < n && (await this.compare(arr, right, '>', largestIndex))) {
+      largestIndex = right;
+    }
+    if (largestIndex !== i) {
+      await this.drawAndSwap(arr, i, largestIndex);
+      await this.maxHeapify(arr, n, largestIndex);
+    }
+  }
 }

src/types.ts

@@ -13,6 +13,7 @@ export enum SortName {
   BitonicSort = 'Bitonic Sort',
   BullySort = 'Bully Sort',
   AverageSort = 'Average Sort',
+  Heapsort = 'Heapsort',
 }
 
 export type SortAlgorithm = (
@@ -26,6 +27,7 @@ export type AlgorithmOptions = {
   type: 'iterative' | 'recursive';
   base: number;
   shrinkFactor: number;
+  heapType: 'max' | 'min';
 };
 
 export enum ResetPreset {

src/utils.ts

@@ -59,6 +59,7 @@ export const sortNameToSortType: Record<SortName, string> = {
   [SortName.BitonicSort]: SortType.Comparison,
   [SortName.BullySort]: SortType.Comparison,
   [SortName.AverageSort]: SortType.Comparison,
+  [SortName.Heapsort]: SortType.Comparison,
 };
 
 // something that sounds good