@raikuxq/alg-ds 1.0.2 → 1.1.2

package/src/index.ts

@@ -1,40 +1,44 @@
-/**
- * Write your code here
- */
-// import { demoBst, demoBstObjects } from "./demo/demo.bst";
-// import { bstCompare } from "./demo/performance/bst-compare";
-// import { demoStack } from "./demo/demo.stack";
-// import { perfQueue, perfStack } from "./demo/performance/ds-compare";
-// import { demoLinkedList } from "./demo/demo.linked-list";
-// import { demoQueue } from "./demo/demo.queue";
-// import {
-//   demoDirectedGraph,
-//   demoGraphGenerated,
-//   demoUndirectedGraph,
-// } from "./demo/demo.graph";
-// import { demoLoopedArray } from "./demo/demo.looped-array";
-// import { compareAllSortTypes } from "./demo/performance/sort-compare";
-//
-// demoLinkedList();
-// // console.log("================================================================");
-// demoLoopedArray();
-// // console.log("================================================================");
-// demoQueue();
-// // console.log("================================================================");
-// demoStack();
-// // console.log("================================================================");
-// demoUndirectedGraph();
-// // console.log("================================================================");
-// demoDirectedGraph();
-// // console.log("================================================================");
-// demoGraphGenerated();
-// // console.log("================================================================");
-// compareAllSortTypes();
-// // console.log("===========================================================");
-// perfQueue();
-// // console.log("===========================================================");
-// perfStack();
-// // console.log("===========================================================");
-// demoBst();
-// // console.log("===========================================================");
-// bstCompare();
+/**
+ * Write your code here
+ */
+
+// import { demoHashtable } from "./demo/demo.hashtable";
+// import { demoBst, demoBstObjects } from "./demo/demo.bst";
+// import { bstCompare } from "./demo/performance/bst-compare";
+// import { demoStack } from "./demo/demo.stack";
+// import { perfQueue, perfStack } from "./demo/performance/ds-compare";
+// import { demoLinkedList } from "./demo/demo.linked-list";
+// import { demoQueue } from "./demo/demo.queue";
+// import {
+//   demoDirectedGraph,
+//   demoGraphGenerated,
+//   demoUndirectedGraph,
+// } from "./demo/demo.graph";
+// import { demoLoopedArray } from "./demo/demo.looped-array";
+// import { compareAllSortTypes } from "./demo/performance/sort-compare";
+//
+// demoLinkedList();
+// // console.log("================================================================");
+// demoLoopedArray();
+// // console.log("================================================================");
+// demoQueue();
+// // console.log("================================================================");
+// demoStack();
+// // console.log("================================================================");
+// demoUndirectedGraph();
+// // console.log("================================================================");
+// demoDirectedGraph();
+// // console.log("================================================================");
+// demoGraphGenerated();
+// // console.log("================================================================");
+// compareAllSortTypes();
+// // console.log("===========================================================");
+// perfQueue();
+// // console.log("===========================================================");
+// perfStack();
+// // console.log("===========================================================");
+// demoBst();
+// // console.log("===========================================================");
+// bstCompare();
+// // console.log("===========================================================");
+// demoHashtable();

package/src/types/IKeyValueStorage.ts

@@ -0,0 +1,8 @@
+export default interface IKeyValueStorage<T> {
+  set(key: string, value: T): void;
+  has(key: string): boolean;
+  get(key: string): T;
+  delete(key: string): void;
+  length(): number;
+  clear(): void;
+}

package/.eslintrc.js

@@ -1,14 +0,0 @@
-module.exports = {
-  root: true,
-  parser: "@typescript-eslint/parser",
-  plugins: ["@typescript-eslint", "prettier"],
-  extends: [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended",
-    "plugin:prettier/recommended",
-    "prettier/@typescript-eslint",
-  ],
-  env: {
-    node: true,
-  },
-};

package/jest.config.js

@@ -1,4 +0,0 @@
-module.exports = {
-  preset: "ts-jest",
-  testEnvironment: "node",
-};

package/nodemon.json

@@ -1,6 +0,0 @@
-{
-  "watch": ["src"],
-  "ext": ".ts,.js",
-  "ignore": [],
-  "exec": "ts-node ./src/index.ts"
-}

package/src/exports/algotirhms.ts

@@ -1,35 +0,0 @@
-import { factorial, memoizedFactorial } from "../algorithms/factorial";
-import { fibonacci, memoizedFibonacci } from "../algorithms/fibonacci";
-import { binarySearch } from "../algorithms/binary-search";
-import { transposeMatrix } from "../algorithms/transpose-matrix";
-import { transposeDirectedGraph } from "../data-structures/Graph/transposing/transposeDirectedGraph";
-import BFSIterationStrategy from "../data-structures/Graph/strategy/BFSIterationStrategy";
-import DFSIterationStrategy from "../data-structures/Graph/strategy/DFSIterationStrategy";
-import DijkstraIterationStrategy from "../data-structures/Graph/strategy/DijkstraIterationStrategy";
-import GraphIteratorBFS from "../data-structures/Graph/iterator/GraphIteratorBFS";
-import GraphIteratorDFS from "../data-structures/Graph/iterator/GraphIteratorDFS";
-import GraphIteratorDijkstra from "../data-structures/Graph/iterator/GraphIteratorDijkstra";
-import { hasPath } from "../data-structures/Graph/searching/hasPath";
-import { shortestPath } from "../data-structures/Graph/searching/shortestPath";
-import { presenterAdjacencyMatrix } from "../data-structures/Graph/presenter/presenterAdjacencyMatrix";
-import { presenterAdjacencyLists } from "../data-structures/Graph/presenter/presenterAdjacencyLists";
-
-export {
-  binarySearch,
-  factorial,
-  memoizedFactorial,
-  memoizedFibonacci,
-  fibonacci,
-  transposeMatrix,
-  GraphIteratorDFS,
-  presenterAdjacencyLists,
-  presenterAdjacencyMatrix,
-  hasPath,
-  shortestPath,
-  DijkstraIterationStrategy,
-  DFSIterationStrategy,
-  BFSIterationStrategy,
-  GraphIteratorBFS,
-  GraphIteratorDijkstra,
-  transposeDirectedGraph,
-};

package/src/exports/constants.ts

@@ -1,3 +0,0 @@
-import { EDGE_EXISTS_STATE, EDGE_NOT_EXISTS_STATE } from "../constants";
-
-export { EDGE_NOT_EXISTS_STATE, EDGE_EXISTS_STATE };

package/src/exports/helpers.ts

@@ -1,13 +0,0 @@
-import { generateRandomGraph } from "../data-structures/Graph/demo/generateRandomGraph";
-import { createLinkedList } from "../helpers/createLinkedList";
-import { createBinaryTree } from "../helpers/createBinaryTree";
-import { createGraph } from "../helpers/createGraph";
-import { createGraphFromMatrix } from "../helpers/createGraphFromMatrix";
-
-export {
-  createGraph,
-  createGraphFromMatrix,
-  createBinaryTree,
-  createLinkedList,
-  generateRandomGraph,
-};

package/src/exports/main.ts

@@ -1,21 +0,0 @@
-import Queue from "../data-structures/Queue/Queue";
-import Stack from "../data-structures/Stack/Stack";
-import UndirectedGraph from "../data-structures/Graph/UndirectedGraph";
-import DirectedGraph from "../data-structures/Graph/DirectedGraph";
-import BinarySearchTree from "../data-structures/BinaryTree/BinarySearchTree/BinarySearchTree";
-import RandBinarySearchTree from "../data-structures/BinaryTree/RandBinarySearchTree/RandBinarySearchTree";
-import DoubleLinkedList from "../data-structures/LinkedList/DoubleLinkedList/DoubleLinkedList";
-import SingleLinkedList from "../data-structures/LinkedList/SingleLinkedList/SingleLinkedList";
-import LoopedArray from "../data-structures/LoopedArray/LoopedArray";
-
-export {
-  Stack,
-  Queue,
-  SingleLinkedList,
-  DoubleLinkedList,
-  RandBinarySearchTree,
-  BinarySearchTree,
-  DirectedGraph,
-  UndirectedGraph,
-  LoopedArray,
-};

package/src/exports/sorts.ts

@@ -1,7 +0,0 @@
-import { bubbleSort } from "../algorithms/sorts/bubble-sort";
-import { selectSort } from "../algorithms/sorts/select-sort";
-import { mergeSort } from "../algorithms/sorts/merge-sort";
-import { insertionSort } from "../algorithms/sorts/insertion-sort";
-import { quickSort } from "../algorithms/sorts/quick-sort";
-
-export { bubbleSort, insertionSort, mergeSort, selectSort, quickSort };

package/src/exports/types.ts

@@ -1,53 +0,0 @@
-import { ArrayMatrix } from "../types/ArrayMatrix";
-import { EnumTreeTraversalType } from "../types/EnumTreeTraversalType";
-import { EnumBinarySearchTreeType } from "../types/EnumBinarySearchTreeType";
-import { EnumGraphTraversalType } from "../types/EnumGraphTraversalType";
-import { EnumGraphType } from "../types/EnumGraphType";
-import { EnumLinkedListType } from "../types/EnumLinkedListType";
-import { EnumRandomGenerationFormat } from "../types/EnumRandomGenerationFormat";
-import { EnumSortType } from "../types/EnumSortType";
-import { FnSort } from "../types/FnSort";
-import { FnCompareTwo } from "../types/FnCompareTwo";
-import { FnToMemoize } from "../types/FnToMemoize";
-import IArrayFacade from "../types/IArrayFacade";
-import IBiDirectIterator from "../types/IBiDirectIterator";
-import IBiDirectIterable from "../types/IBiDirectIterable";
-import IIterable from "../types/IIterable";
-import IIterator from "../types/IIterator";
-import IBinaryTree from "../types/IBinaryTree";
-import IConvertableToArray from "../types/IConvertableToArray";
-import IGraph from "../types/IGraph";
-import IGraphCreator from "../types/IGraphCreator";
-import IGraphIterationStrategy from "../types/IGraphIterationStrategy";
-import IGraphIterator from "../types/IGraphIterator";
-import ILinearStorage from "../types/ILinearStorage";
-import ILinearStorageRA from "../types/ILinearStorageRA";
-import ILinkedList from "../types/ILinkedList";
-
-export {
-  IGraph,
-  IGraphIterator,
-  IGraphIterationStrategy,
-  IIterator,
-  IIterable,
-  IGraphCreator,
-  IBiDirectIterable,
-  IBiDirectIterator,
-  EnumGraphType,
-  EnumSortType,
-  FnSort,
-  EnumGraphTraversalType,
-  EnumTreeTraversalType,
-  EnumBinarySearchTreeType,
-  IBinaryTree,
-  EnumLinkedListType,
-  ILinkedList,
-  ILinearStorage,
-  ILinearStorageRA,
-  IArrayFacade,
-  IConvertableToArray,
-  ArrayMatrix,
-  FnCompareTwo,
-  EnumRandomGenerationFormat,
-  FnToMemoize,
-};

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

@@ -1,25 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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);
-  });
-});