feat: average sort

Author: Oskar Widmark

src/App.tsx

@@ -95,6 +95,7 @@ class App extends React.Component<Props> {
     this.sortingAlgorithms = new SortingAlgorithms(
       this.state.settings.columnNbr,
       this.compare,
+      this.valueCompare,
       this.drawAndSwap,
     );
 
@@ -270,6 +271,43 @@ class App extends React.Component<Props> {
     }
   };
 
+  valueCompare = async (
+    arr: SortValue[],
+    i: number,
+    operator: Operator,
+    value: number,
+  ): Promise<boolean> => {
+    if (!this.state.isSorting) throw Error('isSorting is false!');
+    this.nbrOfComparisons++;
+    if (this.state.settings.compareTime) {
+      // With a zero compareTime, maximum update depth will be exceeded
+      // when updating state too often
+      this.setState((prevState: typeof this.state) => ({
+        nbrOfComparisons: prevState.nbrOfComparisons + 1,
+      }));
+      this.canvasController.highlightColumns(arr, [i]);
+      await sleep(this.state.settings.compareTime);
+    }
+
+    if (
+      sortNameToSortType[this.state.settings.chosenSortAlg] ===
+      SortType.Comparison
+    ) {
+      this.playSoundForColumn(arr, i);
+    }
+
+    switch (operator) {
+      case '<':
+        return arr[i].value < value;
+      case '>':
+        return arr[i].value > value;
+      case '<=':
+        return arr[i].value <= value;
+      case '>=':
+        return arr[i].value >= value;
+    }
+  };
+
   public async swap(arr: SortValue[], i1: number, i2: number) {
     if (!this.state.isSorting) throw Error('isSorting is false!');
 

src/sorting-algorithms.ts

@@ -21,6 +21,7 @@ export class SortingAlgorithms {
     [SortName.ShellSort]: this.shellSort,
     [SortName.BitonicSort]: this.bitonicSort,
     [SortName.BullySort]: this.bullySort,
+    [SortName.AverageSort]: this.averageSort,
     // 'Bully Sort 2': this.bullySort2,
   };
 
@@ -32,6 +33,12 @@ export class SortingAlgorithms {
       operator: Operator,
       j: number,
     ) => Promise<boolean>,
+    private valueCompare: (
+      arr: SortValue[],
+      i: number,
+      operator: Operator,
+      value: number,
+    ) => Promise<boolean>,
     private drawAndSwap: (
       arr: SortValue[],
       i: number,
@@ -533,4 +540,36 @@ public async   mergeSort(arr, start, end){
       }
     }
   }
+
+  public async averageSort(arr: SortValue[]) {
+    await this._averageSort(arr, 0, this._columnNbr);
+  }
+
+  public async _averageSort(arr: SortValue[], start: number, end: number) {
+    if (end - start <= 1) return;
+
+    let sum = 0;
+    for (let i = start; i < end; i++) {
+      // for highlighting and counting comparison
+      // TODO: replace
+      await this.valueCompare(arr, i, '>', 0);
+      sum += arr[i].value;
+    }
+    const avg = sum / (end - start);
+    const mid = Math.floor((start + end) / 2);
+
+    let j = start;
+    for (let i = mid; i < end; i++) {
+      while (await this.valueCompare(arr, j, '<', avg)) {
+        j++;
+      }
+      if (await this.valueCompare(arr, i, '<', avg)) {
+        await this.drawAndSwap(arr, i, j);
+        j++;
+      }
+    }
+
+    await this._averageSort(arr, start, mid);
+    await this._averageSort(arr, mid, end);
+  }
 }

src/types.ts

@@ -12,6 +12,7 @@ export enum SortName {
   ShellSort = 'Shell Sort',
   BitonicSort = 'Bitonic Sort',
   BullySort = 'Bully Sort',
+  AverageSort = 'Average Sort',
 }
 
 export type SortAlgorithm = (

src/utils.ts

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