added sorts

Author: shkvik

src/main.ts

@@ -1,9 +1,15 @@
 import { searchDBG } from "./array/search-in-rotated-sorted-array";
 import { flatDBG } from "./js_core/flatten";
 import { findAnagramsDBG } from "./string/find-anagrams";
+import { isOneEditDistanceDBG } from "./string/is-one-edit-distance";
 import { lengthOfLongestSubstringDBG } from "./string/longest-substring.string";
 import { testValidPalindrome } from "./string/valid-palindrome";
 import { EventEmitter } from 'node:events';
+import './sort';
 
 
-isOneEditDistanceDBG();
+const t = [3,1,2].insertionSort();
+
+console.log(t)
+
+//isOneEditDistanceDBG();

src/sort/bubble.sort.ts

@@ -0,0 +1,17 @@
+import { defaultComparator } from "./utilities";
+
+Array.prototype.bubbleSort = function<T>(
+  compareFn: (a: T, b: T) => number = defaultComparator
+): T[] {
+  const arr = this as T[];
+  const len = arr.length;
+
+  for (let i = 0; i < len; i++) {
+    for (let j = 0; j < len - 1 - i; j++) {
+      if (compareFn(arr[j], arr[j + 1]) > 0) {
+        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
+      }
+    }
+  }
+  return arr;
+}

src/sort/index.ts

@@ -0,0 +1,2 @@
+export * from './bubble.sort';
+export * from './selection.sort';

src/sort/insertion.sort.ts

@@ -0,0 +1,20 @@
+import { defaultComparator } from "./utilities";
+
+Array.prototype.insertionSort = function<T>(
+  compareFn: (a: T, b: T) => number = defaultComparator
+): T[] {
+  const arr = this as T[];
+  const len = arr.length;
+
+  for (let i = 1; i < len; i++) {
+    let current = arr[i];
+    let j = i - 1;
+    while (j >= 0 && compareFn(arr[j], current) > 0) {
+      arr[j + 1] = arr[j];
+      j--;
+    }
+    arr[j + 1] = current;
+  }
+
+  return arr;
+};

src/sort/merge.sort.ts

@@ -0,0 +1,35 @@
+import { defaultComparator } from "./utilities";
+
+Array.prototype.mergeSort = function<T>(
+  compareFn: (a: T, b: T) => number = defaultComparator
+): T[] {
+  const arr = this as T[];
+
+  const merge = (left: T[], right: T[]): T[] => {
+    const result: T[] = [];
+    let i = 0;
+    let j = 0;
+
+    while (i < left.length && j < right.length) {
+      if (compareFn(left[i], right[j]) <= 0) {
+        result.push(left[i]);
+        i++;
+      } else {
+        result.push(right[j]);
+        j++;
+      }
+    }
+
+    return result.concat(left.slice(i)).concat(right.slice(j));
+  };
+
+  if (arr.length <= 1) {
+    return arr;
+  }
+
+  const mid = Math.floor(arr.length / 2);
+  const left = arr.slice(0, mid).mergeSort(compareFn);
+  const right = arr.slice(mid).mergeSort(compareFn);
+
+  return merge(left, right);
+};

src/sort/quick.sort.ts

@@ -0,0 +1,18 @@
+import { defaultComparator } from "./utilities";
+
+Array.prototype.quickSort = function<T>(
+  compareFn: (a: T, b: T) => number = defaultComparator
+): T[] {
+  const arr = this as T[];
+
+  if (arr.length <= 1) {
+    return arr;
+  }
+
+  const pivot = arr[Math.floor(arr.length / 2)];
+  const left = arr.filter((x) => compareFn(x, pivot) < 0);
+  const right = arr.filter((x) => compareFn(x, pivot) > 0);
+  const middle = arr.filter((x) => compareFn(x, pivot) === 0);
+
+  return left.quickSort(compareFn).concat(middle, right.quickSort(compareFn));
+};

src/sort/selection.sort.ts

@@ -0,0 +1,22 @@
+import { defaultComparator } from "./utilities";
+
+Array.prototype.selectionSort = function<T>(
+  compareFn: (a: T, b: T) => number = defaultComparator
+): T[] {
+  const arr = this as T[];
+  const len = arr.length;
+
+  for (let i = 0; i < len; i++) {
+    let minIndex = i; 
+    for (let j = i + 1; j < len; j++) {
+      if (compareFn(arr[j], arr[minIndex]) < 0) {
+        minIndex = j;
+      }
+    }
+    if (minIndex !== i) {
+      [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
+    }
+  }
+
+  return arr;
+}

src/sort/sort.d.ts

@@ -0,0 +1,57 @@
+export declare global {
+  interface Array<T> {
+    /**
+     * @default runtime: O(n^2) memory: O(1)
+     */
+    bubbleSort(compareFn?: (a: T, b: T) => number): this;
+    /**
+     * @default runtime: O(n^2) memory: O(1)
+     */
+    selectionSort(compareFn?: (a: T, b: T) => number): this;
+    /**
+     * @default runtime: O(n^2) memory: O(1)
+     */
+    insertionSort(compareFn?: (a: T, b: T) => number): this;
+    /**
+     * @default runtime: O(n log n) memory: O(n)
+     */
+    mergeSort(compareFn?: (a: T, b: T) => number): this;
+    /**
+     * @default
+     * runtime: O(n log n) (average case), O(n^2) (worst case) 
+     * memory: O(log n) (for recursion stack)
+     */
+    quickSort(compareFn?: (a: T, b: T) => number): this;
+    /**
+     * @default runtime: O(n log n) memory: O(1)
+     */
+    heapSort(compareFn?: (a: T, b: T) => number): this;
+    /**
+     * @default runtime: O(n * k) memory: O(n)
+     */
+    radixSort(compareFn?: (a: T, b: T) => number): this;
+    /**
+     * @default runtime: O(n * k) memory: O(n)
+     */
+    countingSort(compareFn?: (a: T, b: T) => number): this;
+    /**
+     * @default runtime: O(n + k) memory: O(n + k)
+     */
+    bucketSort(compareFn?: (a: T, b: T) => number): this;
+    /**
+     * @default 
+     * runtime: O(n log n) (average case), O(n^2) (worst case) 
+     * memory: O(1) (for recursion stack)
+     */
+    shellSort(compareFn?: (a: T, b: T) => number): this;
+    /**
+     * @default runtime: O(n ^ 2) memory: O(1)
+     */
+    cocktailSort(compareFn?: (a: T, b: T) => number): this;
+    /**
+     * @default runtime: O(n ^ 2) memory: O(1)
+     */
+    combSort(compareFn?: (a: T, b: T) => number): this;
+  }
+}
+

src/sort/utilities.ts

@@ -0,0 +1 @@
+export const defaultComparator = <T>(a: T, b: T) => (a > b ? 1 : a < b ? -1 : 0);

src/string/is-one-edit-distance.ts

@@ -17,11 +17,15 @@ function isOneEditDistance(s: string, t: string): boolean {
       }
     }
   }
-  return lenS + 1 === lenT;
+  return true;
 }
 
 export const isOneEditDistanceDBG = () => {
   const tests = [
+    {
+      input: { s: "120031", t: "120032" },
+      result: true
+    },
     {
       input: { s: "ab", t: "acb" },
       result: true
@@ -33,7 +37,8 @@ export const isOneEditDistanceDBG = () => {
     {
       input: { s: "1203", t: "1213" },
       result: true
-    }
+    },
+    
   ];
 
   tests.forEach((test, index) => {

tsconfig.build.json

@@ -1,4 +1,9 @@
 {
+  "compilerOptions": {
+    "paths": {
+      "@sorts": ["src/sort/index"] 
+    }
+  },
   "extends": "./tsconfig.json",
   "exclude": ["node_modules", "dist" ]
 }