feat: add child count to heap sort

Author: Oskar Widmark

src/Options.tsx

@@ -24,7 +24,7 @@ const getAlgorithmOptionFields = (
     case SortName.CombSort:
       return ['shrinkFactor'];
     case SortName.Heapsort:
-      return ['heapType'];
+      return ['heapType', 'childCount'];
     default:
       return [];
   }
@@ -36,6 +36,7 @@ const isValidOption = (
 ): value is AlgorithmOptions[typeof field] => {
   switch (field) {
     case 'base':
+    case 'childCount':
       return Number(value) >= 2 && Number.isInteger(Number(value));
     case 'shrinkFactor':
       return Number(value) > 1;
@@ -50,6 +51,7 @@ const ALGORITHM_OPTION_LABELS: Record<keyof AlgorithmOptions, string> = {
   shrinkFactor: 'Shrink Factor',
   heapType: 'Heap Type',
   parallel: 'Run in parallel',
+  childCount: '# of children',
 };
 
 const ALGORITHM_OPTION_TEXT_FIELD_TYPES: Record<
@@ -61,6 +63,7 @@ const ALGORITHM_OPTION_TEXT_FIELD_TYPES: Record<
   shrinkFactor: 'number',
   heapType: 'select',
   parallel: 'checkbox',
+  childCount: 'number',
 };
 
 const ALGORITHM_OPTION_VALUES: Record<
@@ -72,6 +75,7 @@ const ALGORITHM_OPTION_VALUES: Record<
   shrinkFactor: [],
   heapType: ['max', 'min'],
   parallel: [],
+  childCount: [],
 };
 
 const ALGORITHM_OPTION_VALUE_LABELS: Record<
@@ -130,7 +134,7 @@ export function Options({
       >
         Options
       </Typography>
-      <Grid2 container>
+      <Grid2 container spacing={2}>
         {algorithmOptionFields.map((field) => (
           <OptionField
             key={field}
@@ -153,7 +157,7 @@ const OptionField = (props: {
   switch (ALGORITHM_OPTION_TEXT_FIELD_TYPES[field]) {
     case 'checkbox':
       return (
-        <FormControl key={field} component="fieldset">
+        <FormControl key={field} component="fieldset" sx={{ mt: -1 }}>
           <LabeledCheckbox
             label={ALGORITHM_OPTION_LABELS[field]}
             checked={Boolean(nonValidatedOptions[field])}

src/constants.ts

@@ -38,6 +38,7 @@ export const INIT_SETTINGS: Settings = {
     shrinkFactor: 1.3,
     heapType: 'max',
     parallel: false,
+    childCount: 2,
   },
   colorPreset: ColorPreset.Rainbow,
   columnColor1: '#ffffff',

src/sorting-algorithms.ts

@@ -837,74 +837,76 @@ public async   mergeSort(arr, start, end){
   public async heapsort(arr: SortValue[], options: AlgorithmOptions) {
     switch (options.heapType) {
       case 'min':
-        return await this.minHeapsort(arr);
+        return await this.minHeapsort(arr, options.childCount);
       case 'max':
-        return await this.maxHeapsort(arr);
+        return await this.maxHeapsort(arr, options.childCount);
     }
   }
 
-  private async minHeapsort(arr: SortValue[]) {
+  private async minHeapsort(arr: SortValue[], childCount: number) {
     for (let i = Math.ceil(arr.length / 2) + 1; i < arr.length; i++) {
-      await this.minHeapify(arr, 0, i);
+      await this.minHeapify(arr, 0, i, childCount);
     }
     for (let i = 0; i < arr.length; i++) {
       await this.context.drawAndSwap(arr, arr.length - 1, i);
-      await this.minHeapify(arr, i, arr.length - 1);
+      await this.minHeapify(arr, i, arr.length - 1, childCount);
     }
   }
 
-  private async maxHeapsort(arr: SortValue[]) {
+  private async maxHeapsort(arr: SortValue[], childCount: number) {
     for (let i = Math.floor(arr.length / 2) - 1; i >= 0; i--) {
-      await this.maxHeapify(arr, arr.length, i);
+      await this.maxHeapify(arr, arr.length, i, childCount);
     }
     for (let i = arr.length - 1; i > 0; i--) {
       await this.context.drawAndSwap(arr, 0, i);
-      await this.maxHeapify(arr, i, 0);
+      await this.maxHeapify(arr, i, 0, childCount);
     }
   }
 
   // This a reversed heap, with the smallest element at the last index
-  private async minHeapify(arr: SortValue[], n: number, i: number) {
+  private async minHeapify(
+    arr: SortValue[],
+    n: number,
+    i: number,
+    childCount: 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.context.compare(arr, smallestIndex, '>', left))
-    ) {
-      smallestIndex = left;
-    }
-    if (
-      right > n &&
-      (await this.context.compare(arr, smallestIndex, '>', right))
-    ) {
-      smallestIndex = right;
+    for (let c = 0; c < childCount; c++) {
+      const childIndex =
+        arr.length - 1 - (childCount * (arr.length - 1 - i) + 1 + c);
+      if (
+        childIndex > n &&
+        (await this.context.compare(arr, childIndex, '<', smallestIndex))
+      ) {
+        smallestIndex = childIndex;
+      }
     }
     if (smallestIndex !== i) {
       await this.context.drawAndSwap(arr, i, smallestIndex);
-      await this.minHeapify(arr, n, smallestIndex);
+      await this.minHeapify(arr, n, smallestIndex, childCount);
     }
   }
 
-  private async maxHeapify(arr: SortValue[], n: number, i: number) {
+  private async maxHeapify(
+    arr: SortValue[],
+    n: number,
+    i: number,
+    childCount: number,
+  ) {
     let largestIndex = i;
-    const left = 2 * i + 1;
-    const right = 2 * i + 2;
-    if (
-      left < n &&
-      (await this.context.compare(arr, left, '>', largestIndex))
-    ) {
-      largestIndex = left;
-    }
-    if (
-      right < n &&
-      (await this.context.compare(arr, right, '>', largestIndex))
-    ) {
-      largestIndex = right;
+    for (let c = 0; c < childCount; c++) {
+      const childIndex = childCount * i + 1 + c;
+      if (
+        childIndex < n &&
+        (await this.context.compare(arr, childIndex, '>', largestIndex))
+      ) {
+        largestIndex = childIndex;
+      }
     }
+
     if (largestIndex !== i) {
-      await this.context.drawAndSwap(arr, i, largestIndex);
-      await this.maxHeapify(arr, n, largestIndex);
+      await this.context.drawAndSwap(arr, i, largestIndex, childCount);
+      await this.maxHeapify(arr, n, largestIndex, childCount);
     }
   }
 

src/types.ts

@@ -32,6 +32,7 @@ export type AlgorithmOptions = {
   shrinkFactor: number;
   heapType: 'max' | 'min';
   parallel: boolean;
+  childCount: number;
 };
 
 export enum ResetPreset {