Start reworking lib to DENO

Author: G43riko

.gitpod.yml

@@ -0,0 +1,10 @@
+# This configuration file was automatically generated by Gitpod.
+# Please adjust to your needs (see https://www.gitpod.io/docs/introduction/learn-gitpod/gitpod-yaml)
+# and commit this file to your remote git repository to share the goodness with others.
+
+# Learn more from ready-to-use templates: https://www.gitpod.io/docs/introduction/getting-started/quickstart
+
+tasks:
+  - init: yarn install && yarn run build
+
+

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "deno.enable": true
+}

deno.json

@@ -0,0 +1,8 @@
+{
+    "name": "@g43/utils",
+    "tasks": {
+        "bench": "deno bench src/"
+    },
+    "version": "0.1.0",
+    "exports": "./src/index.ts"
+}

src/index.ts

@@ -1,2 +0,0 @@
-export * from "./GUtils";
-

src/models/path/a-star/a-star.ts renamed to src/sort/array.mock.ts

@@ -0,0 +1,19 @@
+export function insertionSort<T>(list: readonly T[], comparator: (a: T, b: T) => number): void {
+    const listCopy = [...list];
+    for (let i = 1; i < listCopy.length; i++) {
+        const item = listCopy[i];
+        if (comparator(item, listCopy[i - 1]) < 0) {
+            sortUpLowToHigh(listCopy, i, comparator);
+        }
+    }
+}
+
+function sortUpLowToHigh<T>(list: T[], i: number, comparator: (a: T, b: T) => number): void {
+    const item     = list[i];
+    let attemptPos = i - 1;
+    while (attemptPos !== 0 && comparator(list[attemptPos - 1], item, ) > 0) {
+        attemptPos--;
+    }
+    list.splice(i, 1);
+    list.splice(attemptPos, 0, item);
+}

src/sort/insertion-sort.ts

@@ -0,0 +1,40 @@
+let array: any[]          = [];
+let tempMergeArray: any[] = [];
+
+export function mergeSort<T>(arr: T[], comparator: (a: T, b: T) => number): void {
+    array          = arr;
+    tempMergeArray = new Array<T>(arr.length);
+    doMergeSort(0, arr.length - 1, comparator);
+}
+
+function doMergeSort<T>(lowerIndex: number, higherIndex: number, comparator: (a: T, b: T) => number): void {
+    if (lowerIndex >= higherIndex) {
+        return;
+    }
+    const middle = Math.floor(lowerIndex + (higherIndex - lowerIndex) / 2);
+    doMergeSort(lowerIndex, middle, comparator);
+    doMergeSort(middle + 1, higherIndex, comparator);
+    mergeParts(lowerIndex, middle, higherIndex, comparator);
+}
+
+function mergeParts<T>(lowerIndex: number, middle: number, higherIndex: number, comparator: (a: T, b: T) => number): void {
+    for (let index = lowerIndex; index <= higherIndex; index++) {
+        tempMergeArray[index] = array[index];
+    }
+
+    let i = lowerIndex;
+    let j = middle + 1;
+    let k = lowerIndex;
+    while (i <= middle && j <= higherIndex) {
+        if (comparator(tempMergeArray[i], tempMergeArray[j]) <= 0) {
+            array[k] = tempMergeArray[i++];
+        } else {
+            array[k] = tempMergeArray[j++];
+        }
+        k++;
+    }
+    while (i <= middle) {
+        array[k++] = tempMergeArray[i++];
+    }
+
+}

src/sort/merge-sort.ts

@@ -0,0 +1,45 @@
+let array: any[]         = [];
+let tmpValue: any | null = null;
+
+
+export function quickSort<T>(arr: T[], comparator: (a: T, b: T) => number): void {
+    if (!arr?.length) {
+        return;
+    }
+
+    array = arr;
+
+    doQuickSort(0, array.length - 1, comparator);
+}
+
+function doQuickSort<T>(lowerIndex: number, higherIndex: number, comparator: (a: T, b: T) => number): void {
+    let i = lowerIndex;
+    let j = higherIndex;
+
+    const pivot = array[~~(lowerIndex + (higherIndex - lowerIndex) / 2)];
+    while (i <= j) {
+        while (comparator(array[i], pivot) < 0) {
+            i++;
+        }
+        while (comparator(array[j], pivot) > 0) {
+            j--;
+        }
+
+        if (i <= j) {
+            exchangeNumbers(i++, j--);
+        }
+    }
+
+    if (lowerIndex < j) {
+        doQuickSort(lowerIndex, j, comparator);
+    }
+    if (i < higherIndex) {
+        doQuickSort(i, higherIndex, comparator);
+    }
+}
+
+function exchangeNumbers(i: number, j: number): void {
+    tmpValue = array[i];
+    array[i] = array[j];
+    array[j] = tmpValue;
+}

src/sort/quick-sort.ts

@@ -0,0 +1,41 @@
+import { quickSort } from "./quick-sort.ts";
+import { insertionSort } from "./insertion-sort.ts";
+import { mergeSort } from "./merge-sort.ts";
+const SIZE = 100000
+const randomArray = new Array<number>(SIZE).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER));
+const ascArray = new Array<number>(SIZE).fill(0).map((_, i) => i);
+const descArray = new Array<number>(SIZE).fill(0).map((_, i) => SIZE - i);
+
+
+Deno.bench("quickSort", { group: "sort.random" }, () => {
+    quickSort(randomArray, (a, b) => a - b);
+});
+Deno.bench("insertionSort", { group: "sort.random" }, () => {
+    insertionSort(randomArray, (a, b) => a - b);
+});
+Deno.bench("mergeSort", { group: "sort.random" }, () => {
+    mergeSort(randomArray, (a, b) => a - b);
+});
+
+
+
+Deno.bench("quickSort", { group: "sort.asc" }, () => {
+    quickSort(ascArray, (a, b) => a - b);
+});
+Deno.bench("insertionSort", { group: "sort.asc" }, () => {
+    insertionSort(ascArray, (a, b) => a - b);
+});
+Deno.bench("mergeSort", { group: "sort.asc" }, () => {
+    mergeSort(ascArray, (a, b) => a - b);
+});
+
+Deno.bench("quickSort", { group: "sort.desc" }, () => {
+    quickSort(descArray, (a, b) => a - b);
+});
+Deno.bench("insertionSort", { group: "sort.desc" }, () => {
+    insertionSort(descArray, (a, b) => a - b);
+});
+Deno.bench("mergeSort", { group: "sort.desc" }, () => {
+    mergeSort(descArray, (a, b) => a - b);
+});
+