@raikuxq/alg-ds 1.0.0

package/src/types/IIterator.ts

@@ -0,0 +1,14 @@
+export default interface IIterator<T> {
+  /**
+   * Will do one iteration and returns next item value
+   */
+  next(): T;
+  /**
+   * Will returns current value
+   */
+  current(): T;
+  /**
+   * Check if next element exists
+   */
+  hasNext(): boolean;
+}

package/src/types/ILinearStorage.ts

@@ -0,0 +1,11 @@
+export default interface ILinearStorage<T> {
+  peek(): T;
+  push(value: T): void;
+  pop(): T;
+  has(value: T): boolean;
+  isEmpty(): boolean;
+  isFull(): boolean;
+  length(): number;
+  clear(): void;
+  reverse(): void;
+}

package/src/types/ILinearStorageRA.ts

@@ -0,0 +1,14 @@
+import ILinearStorage from "./ILinearStorage";
+
+/**
+ * Interface extends default linear storage with methods that allows read/write operations for all storage elements
+ * RA - randomly accessible
+ */
+export default interface ILinearStorageRA<T> extends ILinearStorage<T> {
+  peekFromStart(): T;
+  peekByIndex(index: number): T;
+  unshift(value: T): void;
+  pushFromIndex(value: T, fromIndex: number): void;
+  shift(): T;
+  deleteFromIndex(fromIndex: number): T;
+}

package/src/types/ILinkedList.ts

@@ -0,0 +1,6 @@
+import ILinearStorageRA from "./ILinearStorageRA";
+import IConvertableToArray from "./IConvertableToArray";
+
+export default interface ILinkedList<T>
+  extends ILinearStorageRA<T>,
+    IConvertableToArray<T> {}

package/src/utils.ts

@@ -0,0 +1,65 @@
+import { performance } from "perf_hooks";
+
+/**
+ * Will find min value in the whole array and return its index
+ */
+export const getMinIndex = (arr: Array<number>): number => {
+  return arr.reduce((minIndex, item, index): number => {
+    return item < arr[minIndex] ? index : minIndex;
+  }, 0);
+};
+
+/**
+ * Will find min value in range between fromIndex and end of array
+ */
+export const getMinIndexFromIndex = (
+  arr: Array<number>,
+  fromIndex: number
+): number => {
+  return fromIndex + getMinIndex(arr.slice(fromIndex));
+};
+
+/**
+ * Will swap two items in array
+ * @example swapArrayItems([2,3,5], 1, 2) -> [2,5,3]
+ */
+export const swapArrayItems = <T>(
+  arr: Array<T>,
+  leftIndex: number,
+  rightIndex: number
+): void => {
+  if (leftIndex !== rightIndex) {
+    const temp: T = arr[leftIndex];
+    arr[leftIndex] = arr[rightIndex];
+    arr[rightIndex] = temp;
+  }
+};
+
+/**
+ * Get random number in range
+ */
+export const randomizeNumberInRange = (min: number, max: number): number =>
+  Math.floor(Math.random() * (max - min)) + min;
+
+/**
+ * Round number to 3 digits after
+ */
+export const roundNumber = (num: number): number =>
+  Math.round(num * 1000) / 1000;
+
+/**
+ * Get time execution of function
+ */
+export const perf = (fn: () => void): number => {
+  const perfStart = performance.now();
+  fn();
+  const perfEnd = performance.now();
+  return perfEnd - perfStart;
+};
+
+/**
+ * Get time execution of function
+ */
+export const perfAsync = async (fn: () => void): Promise<number> => {
+  return Promise.resolve(perf(fn));
+};

package/test/unit/algorithms/binary-search.test.ts

@@ -0,0 +1,25 @@
+import { binarySearch } from "../../../src/algorithms/binary-search";
+
+describe("Binary search", () => {
+  it("should find in positive 100 elements", () => {
+    const arr: Array<number> = [];
+    for (let i = 0; i < 100; i++) arr.push(i + 1);
+    const foundElement = binarySearch(arr, 97);
+
+    expect(foundElement).toBe(96);
+  });
+
+  it("should find in negative 100 elements", () => {
+    const arr: Array<number> = [];
+    for (let i = 0; i < 100; i++) arr.push(-100 + i - 1);
+    const foundElement = binarySearch(arr, -97);
+
+    expect(foundElement).toBe(4);
+  });
+
+  it("should return null in empty list", () => {
+    const arr: Array<number> = [];
+
+    expect(binarySearch(arr, 10)).toBeNull();
+  });
+});

package/test/unit/algorithms/factorial.test.ts

@@ -0,0 +1,43 @@
+import {
+  factorial,
+  memoizedFactorial,
+} from "../../../src/algorithms/factorial";
+
+describe("Factorial", () => {
+  const results = new Map<number, number>();
+  const resultsBigValues = new Map<number, number>();
+
+  results
+    .set(5, 120)
+    .set(6, 720)
+    .set(10, 3628800)
+    .set(15, 1307674368000)
+    .set(20, 2432902008176640000)
+    .set(25, 15511210043330985984000000);
+
+  resultsBigValues
+    .set(35, 1.0333147966386144e40)
+    .set(45, 1.1962222086548019e56)
+    .set(77, 1.4518309202828584e113)
+    .set(90, 1.4857159644817607e138)
+    .set(99, 9.33262154439441e155)
+    .set(100, 9.33262154439441e157);
+
+  const resultsKeys = Array.from(results.keys());
+  const resultsBigValuesKeys = Array.from(resultsBigValues.keys());
+
+  describe("without memoize", () => {
+    test.each(resultsKeys)("with n = %i", (n) => {
+      expect(factorial(n)).toBe(results.get(n));
+    });
+  });
+
+  describe("with memoize", () => {
+    test.each(resultsKeys)("with n = %i", (n) => {
+      expect(memoizedFactorial(n)).toBe(results.get(n));
+    });
+    test.each(resultsBigValuesKeys)("with n = %i", (n) => {
+      expect(memoizedFactorial(n)).toBe(resultsBigValues.get(n));
+    });
+  });
+});

package/test/unit/algorithms/fibonacci.test.ts

@@ -0,0 +1,41 @@
+import {
+  fibonacci,
+  memoizedFibonacci,
+} from "../../../src/algorithms/fibonacci";
+
+describe("Fibonacci", () => {
+  const results = new Map<number, number>();
+  const resultsBigValues = new Map<number, number>();
+
+  results
+    .set(5, 5)
+    .set(6, 8)
+    .set(10, 55)
+    .set(15, 610)
+    .set(20, 6765)
+    .set(25, 75025);
+
+  resultsBigValues
+    .set(40, 102334155)
+    .set(45, 1134903170)
+    .set(77, 5527939700884757)
+    .set(90, 2880067194370816120);
+
+  const resultsKeys = Array.from(results.keys());
+  const resultsBigValuesKeys = Array.from(resultsBigValues.keys());
+
+  describe("without memoize", () => {
+    test.each(resultsKeys)("with n = %i", (n) => {
+      expect(fibonacci(n)).toBe(results.get(n));
+    });
+  });
+
+  describe("with memoize", () => {
+    test.each(resultsKeys)("with n = %i", (n) => {
+      expect(memoizedFibonacci(n)).toBe(results.get(n));
+    });
+    test.each(resultsBigValuesKeys)("with n = %i", (n) => {
+      expect(memoizedFibonacci(n)).toBe(resultsBigValues.get(n));
+    });
+  });
+});

package/test/unit/algorithms/sorts.test.ts

@@ -0,0 +1,74 @@
+import { quickSort } from "../../../src/algorithms/sorts/quick-sort";
+import { mergeSort } from "../../../src/algorithms/sorts/merge-sort";
+import { selectSort } from "../../../src/algorithms/sorts/select-sort";
+import { bubbleSort } from "../../../src/algorithms/sorts/bubble-sort";
+import { insertionSort } from "../../../src/algorithms/sorts/insertion-sort";
+import { randomizeArray } from "../../../src/demo/performance/sort-compare";
+import { EnumSortType } from "../../../src/types/EnumSortType";
+
+const createSortFunction = (
+  sortType: string
+): ((arr: Array<number>) => Array<number>) => {
+  switch (sortType) {
+    case EnumSortType.Quick:
+      return quickSort;
+    case EnumSortType.Merge:
+      return mergeSort;
+    case EnumSortType.Selection:
+      return selectSort;
+    case EnumSortType.Bubble:
+      return bubbleSort;
+    case EnumSortType.Insertion:
+      return insertionSort;
+    default:
+      throw new Error("Invalid sort type");
+  }
+};
+
+describe.each([
+  EnumSortType.Merge,
+  EnumSortType.Quick,
+  EnumSortType.Bubble,
+  EnumSortType.Insertion,
+  EnumSortType.Selection,
+])("%s sort", (sortStrategyType: EnumSortType) => {
+  const sort = createSortFunction(sortStrategyType);
+
+  it("should correctly sort with random numbers", () => {
+    const notSortedArr: Array<number> = randomizeArray(100, 500);
+
+    const sortedArr = [...notSortedArr].sort((a: number, b: number) => {
+      if (a > b) return 1;
+      if (a < b) return -1;
+      return 0;
+    });
+
+    expect(sort(notSortedArr)).toEqual(sortedArr);
+  });
+
+  it("should correctly sort an empty array", () => {
+    const emptyArr: Array<number> = [];
+
+    expect(sort(emptyArr)).toEqual(emptyArr);
+  });
+
+  it("should correctly sort already sorted array", () => {
+    const sortedArr = [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5];
+
+    expect(sort(sortedArr)).toEqual(sortedArr);
+  });
+
+  it("should correctly sort an array with repeated numbers", () => {
+    const notSortedArr = [7, 2, 1, 2, 7];
+    const sortedArr = [1, 2, 2, 7, 7];
+
+    expect(sort(notSortedArr)).toEqual(sortedArr);
+  });
+
+  it("should correctly sort an array with float numbers", () => {
+    const notSortedArr = [2.5, -2.5, 0, 5.5, -5.5];
+    const sortedArr = [-5.5, -2.5, 0, 2.5, 5.5];
+
+    expect(sort(notSortedArr)).toEqual(sortedArr);
+  });
+});

package/test/unit/algorithms/transpose-matrix.test.ts

@@ -0,0 +1,39 @@
+import { transposeMatrix } from "../../../src/algorithms/transpose-matrix";
+
+describe("transpose matrix", () => {
+  it("should throw when array is not a matrix", () => {
+    const srcMatrix = [
+      [0, 1],
+      [1, 0],
+      [0, 1],
+    ];
+
+    expect(() => {
+      transposeMatrix(srcMatrix);
+    }).toThrowError();
+  });
+
+  it("should transpose matrix correctly", () => {
+    const srcMatrix = [
+      [0, 1, 1],
+      [0, 0, 1],
+      [1, 0, 0],
+    ];
+
+    expect(transposeMatrix(srcMatrix)).toEqual([
+      [0, 0, 1],
+      [1, 0, 0],
+      [1, 1, 0],
+    ]);
+  });
+
+  it("should return same matrix in case of symmetric matrix", () => {
+    const srcMatrix = [
+      [0, 1, 0],
+      [1, 0, 1],
+      [0, 1, 0],
+    ];
+
+    expect(transposeMatrix(srcMatrix)).toEqual(srcMatrix);
+  });
+});

package/test/unit/data-structures/binary-tree/binary-search-tree.test.ts

@@ -0,0 +1,230 @@
+import { EnumBinarySearchTreeType } from "../../../../src/types/EnumBinarySearchTreeType";
+import { createBinaryTree } from "../../../../src/helpers/createBinaryTree";
+import { EnumTreeTraversalType } from "../../../../src/types/EnumTreeTraversalType";
+
+describe.each([
+  EnumBinarySearchTreeType.BST,
+  EnumBinarySearchTreeType.RANDOMIZED_BST,
+])("%s", (treeType: EnumBinarySearchTreeType) => {
+  describe("constructor", () => {
+    it("should create an empty instance", () => {
+      const tree = createBinaryTree(treeType);
+
+      expect(tree.length()).toBe(0);
+    });
+  });
+
+  describe("method insert", function () {
+    it("should have added elements to be in order", () => {
+      const tree = createBinaryTree(treeType);
+      tree.insert(5);
+      tree.insert(15);
+      tree.insert(10);
+      tree.insert(0);
+      tree.insert(20);
+
+      expect(tree.traverse(EnumTreeTraversalType.InOrder)).toEqual([
+        0,
+        5,
+        10,
+        15,
+        20,
+      ]);
+    });
+  });
+
+  describe("method length", function () {
+    describe("when tree is non empty", () => {
+      describe("after adding", () => {
+        it("should return updated length value", () => {
+          const tree = createBinaryTree(treeType);
+          tree.insert(5);
+          tree.insert(15);
+          tree.insert(10);
+
+          expect(tree.length()).toBe(3);
+        });
+      });
+
+      describe("after deleting", () => {
+        it("should return updated length value", () => {
+          const tree = createBinaryTree(treeType);
+          tree.insert(5);
+          tree.insert(15);
+          tree.insert(10);
+          tree.delete(5);
+
+          expect(tree.length()).toBe(2);
+        });
+      });
+    });
+
+    describe("when tree is empty", () => {
+      it("should return zero value", () => {
+        const tree = createBinaryTree(treeType);
+
+        expect(tree.length()).toBe(0);
+      });
+    });
+  });
+
+  describe("method height", function () {
+    describe("when tree is non empty", () => {
+      describe("after adding", () => {
+        const tree = createBinaryTree(treeType);
+        const length = 300;
+        const arraySrc = Array.from(Array(length).keys());
+        const arrayShuffled = arraySrc
+          .map((item) => item)
+          .sort(() => Math.random() - 0.5);
+        arrayShuffled.forEach((num, index) => {
+          tree.insert(num);
+        });
+        const height = tree.height();
+
+        it("should be equal or greater than log(length)", () => {
+          const expected = Math.ceil(Math.log2(length));
+          expect(height).toBeGreaterThanOrEqual(expected);
+        });
+        it("should be equal or smaller than length", () => {
+          expect(height).toBeLessThanOrEqual(tree.length());
+        });
+      });
+    });
+
+    describe("when tree is empty", () => {
+      const tree = createBinaryTree(treeType);
+
+      it("should return zero value", () => {
+        expect(tree.height()).toBe(0);
+      });
+    });
+  });
+
+  describe("method has", function () {
+    const tree = createBinaryTree(treeType);
+    tree.insert(5);
+
+    it("should return true when value exists", () => {
+      expect(tree.has(5)).toBe(true);
+    });
+
+    it("should return false when value does not exist", () => {
+      expect(tree.has(10)).toBe(false);
+    });
+  });
+
+  describe("method delete", function () {
+    const tree = createBinaryTree(treeType);
+    tree.insert(5);
+    tree.insert(12);
+    tree.insert(7);
+    tree.insert(20);
+
+    tree.delete(12);
+
+    it("should delete element from the tree", () => {
+      expect(tree.has(12)).toBe(false);
+    });
+
+    it("should restructure the tree correctly", () => {
+      expect(tree.traverse(EnumTreeTraversalType.InOrder)).toEqual([5, 7, 20]);
+    });
+  });
+
+  describe("method max", function () {
+    const tree = createBinaryTree(treeType);
+    tree.insert(5);
+    tree.insert(12);
+    tree.insert(7);
+    tree.insert(20);
+
+    it("should be in order", () => {
+      expect(tree.max()).toBe(20);
+    });
+  });
+
+  describe("method min", function () {
+    const tree = createBinaryTree(treeType);
+    tree.insert(5);
+    tree.insert(12);
+    tree.insert(7);
+    tree.insert(20);
+    tree.insert(2);
+
+    it("should be in order", () => {
+      expect(tree.min()).toBe(2);
+    });
+  });
+
+  if (treeType === EnumBinarySearchTreeType.BST) {
+    describe("method subtree", function () {
+      const bst = createBinaryTree(treeType);
+      bst.insert(22);
+      bst.insert(4);
+      bst.insert(16);
+      bst.insert(19);
+      bst.insert(15);
+      bst.insert(8);
+      bst.insert(23);
+      const subtree = bst.subtree(16);
+
+      it("should correctly create subtree", () => {
+        expect(subtree.traverse(EnumTreeTraversalType.InOrder)).toEqual([
+          8,
+          15,
+          16,
+          19,
+        ]);
+      });
+    });
+
+    describe("method traverse", function () {
+      const bst = createBinaryTree(treeType);
+
+      bst.insert(22);
+      bst.insert(4);
+      bst.insert(16);
+      bst.insert(19);
+      bst.insert(15);
+      bst.insert(8);
+      bst.insert(23);
+
+      it("should correctly convert in-order type", () => {
+        expect(bst.traverse(EnumTreeTraversalType.InOrder)).toEqual([
+          4,
+          8,
+          15,
+          16,
+          19,
+          22,
+          23,
+        ]);
+      });
+
+      it("should correctly convert pre-order type", () => {
+        expect(bst.traverse(EnumTreeTraversalType.PreOrder)).toEqual([
+          22,
+          4,
+          8,
+          15,
+          16,
+          19,
+          23,
+        ]);
+      });
+
+      it("should correctly convert post-order type", () => {
+        expect(bst.traverse(EnumTreeTraversalType.PostOrder)).toEqual([
+          4,
+          8,
+          15,
+          16,
+          19,
+          23,
+          22,
+        ]);
+      });
+    });
+  }
+});

package/test/unit/data-structures/graph/graph.create-from-matrix.test.ts

@@ -0,0 +1,106 @@
+import { EnumGraphType } from "../../../../src/types/EnumGraphType";
+import { createGraphFromMatrix } from "../../../../src/helpers/createGraphFromMatrix";
+import { ArrayMatrix } from "../../../../src/types/ArrayMatrix";
+import IGraph from "../../../../src/types/IGraph";
+
+describe("in Directed graph", () => {
+  /**
+   * Get graph adjacency matrix N x N
+   *
+   * @example
+   *
+   * Directed graph:
+   * - Bob [Maria]
+   * - Maria [Bob, John]
+   * - John []
+   *
+   * Its matrix:
+   *       |  Bob  | Maria |  John |
+   * Bob   |   0   |   1   |   0   |
+   * Maria |   1   |   0   |   1   |
+   * John  |   0   |   0   |   0   |
+   */
+  describe("created graph", () => {
+    const fieldsList: Array<string> = ["Bob", "Maria", "John"];
+
+    const matrix: ArrayMatrix = [
+      [0, 1, 0],
+      [1, 0, 1],
+      [0, 0, 0],
+    ];
+    const graph: IGraph<string> = createGraphFromMatrix<string>(
+      matrix,
+      fieldsList,
+      EnumGraphType.Directed
+    );
+
+    it("should contain all vertices", () => {
+      expect(graph.vertices()).toEqual(fieldsList);
+    });
+
+    it("should contain all edges", () => {
+      expect(graph.hasEdge("Bob", "Bob")).toBe(false);
+      expect(graph.hasEdge("Bob", "Maria")).toBe(true);
+      expect(graph.hasEdge("Bob", "John")).toBe(false);
+
+      expect(graph.hasEdge("Maria", "Maria")).toBe(false);
+      expect(graph.hasEdge("Maria", "Bob")).toBe(true);
+      expect(graph.hasEdge("Maria", "John")).toBe(true);
+
+      expect(graph.hasEdge("John", "John")).toBe(false);
+      expect(graph.hasEdge("John", "Bob")).toBe(false);
+      expect(graph.hasEdge("John", "Maria")).toBe(false);
+    });
+  });
+});
+
+describe("in Undirected graph", () => {
+  /**
+   * Get graph adjacency matrix N x N
+   *
+   * @example
+   *
+   * Directed graph:
+   * - Bob [Maria]
+   * - Maria [Bob, John]
+   * - John []
+   *
+   * Its matrix:
+   *       |  Bob  | Maria |  John |
+   * Bob   |   0   |   1   |   0   |
+   * Maria |   1   |   0   |   1   |
+   * John  |   0   |   1   |   0   |
+   */
+  describe("created graph", () => {
+    const fieldsList: Array<string> = ["Bob", "Maria", "John"];
+
+    const matrix: ArrayMatrix = [
+      [0, 1, 0],
+      [1, 0, 1],
+      [0, 1, 0],
+    ];
+    const graph: IGraph<string> = createGraphFromMatrix<string>(
+      matrix,
+      fieldsList,
+      EnumGraphType.Undirected
+    );
+
+    it("should contain all vertices", () => {
+      expect(graph.vertices()).toEqual(fieldsList);
+    });
+
+    it("should contain all edges", () => {
+      expect(graph.hasEdge("Bob", "Bob")).toBe(false);
+      expect(graph.hasEdge("Bob", "Maria")).toBe(true);
+      expect(graph.hasEdge("Bob", "John")).toBe(false);
+
+      expect(graph.hasEdge("Maria", "Maria")).toBe(false);
+      expect(graph.hasEdge("Maria", "Bob")).toBe(true);
+      expect(graph.hasEdge("Maria", "John")).toBe(true);
+
+      expect(graph.hasEdge("John", "John")).toBe(false);
+      expect(graph.hasEdge("John", "Bob")).toBe(false);
+      expect(graph.hasEdge("John", "Maria")).toBe(true);
+    });
+  });
+});