@raikuxq/alg-ds 1.0.0

package/src/demo/performance/bst-compare.ts

@@ -0,0 +1,38 @@
+import RandBinarySearchTree from "../../data-structures/BinaryTree/RandBinarySearchTree/RandBinarySearchTree";
+import BinarySearchTree from "../../data-structures/BinaryTree/BinarySearchTree/BinarySearchTree";
+import { EnumTreeTraversalType } from "../../types/EnumTreeTraversalType";
+import IBinaryTree from "../../types/IBinaryTree";
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const util = require("util");
+
+const logTree = <T>(tree: IBinaryTree<T>) => {
+  console.log("HEIGHT");
+  console.log(tree.height());
+  console.log("LENGTH");
+  console.log(tree.length());
+  console.log("MAX");
+  console.log(tree.max());
+  console.log("MIN");
+  console.log(tree.min());
+};
+
+export const bstCompare = (): void => {
+  const bstLeaf = new BinarySearchTree<number>();
+  const bstRand = new RandBinarySearchTree<number>();
+
+  const arraySrc = Array.from(Array(1000).keys());
+
+  arraySrc.forEach((num, index) => {
+    bstLeaf.insert(num);
+    bstRand.insert(num);
+  });
+
+  console.log(
+    "***************************LEAF TREE*****************************"
+  );
+  logTree<number>(bstLeaf);
+  console.log(
+    "\n\n\n***************************RAND TREE*****************************"
+  );
+  logTree<number>(bstRand);
+};

package/src/demo/performance/ds-compare.ts

@@ -0,0 +1,58 @@
+import Queue from "../../data-structures/Queue/Queue";
+import Stack from "../../data-structures/Stack/Stack";
+import ILinearStorage from "../../types/ILinearStorage";
+import { perf, roundNumber } from "../../utils";
+
+export const pushToLinearDS = (
+  linearDS: ILinearStorage<string>,
+  elementsCount: number,
+  item: string
+): void => {
+  for (let i = 0; i < elementsCount; i++) {
+    linearDS.push(`${item}_${i}`);
+  }
+};
+
+export const perfLinearDS = (linearDS: ILinearStorage<string>): void => {
+  let elementsCount = 50;
+
+  while (elementsCount <= 5000000) {
+    pushToLinearDS(linearDS, elementsCount, "qwerty");
+
+    const perfPush = perf(() => {
+      linearDS.push("qwerty");
+    });
+    const perfPeek = perf(() => {
+      linearDS.peek();
+    });
+
+    const perfPop = perf(() => {
+      linearDS.pop();
+    });
+    const perfHas = perf(() => {
+      linearDS.has(`qwerty_${elementsCount - 10}`);
+    });
+
+    console.log(`N: ${elementsCount} push: ${roundNumber(perfPush)}ms`);
+    console.log(`N: ${elementsCount} peek: ${roundNumber(perfPeek)}ms`);
+    console.log(`N: ${elementsCount} pop: ${roundNumber(perfPop)}ms`);
+    console.log(`N: ${elementsCount} has: ${roundNumber(perfHas)}ms`);
+    console.log("=========================");
+
+    elementsCount *= 10;
+  }
+};
+
+export const perfQueue = (): void => {
+  console.log(`QUEUE PERFORMANCE TEST:`);
+  const queue: ILinearStorage<string> = new Queue<string>();
+
+  perfLinearDS(queue);
+};
+
+export const perfStack = (): void => {
+  console.log(`STACK PERFORMANCE TEST:`);
+  const stack: ILinearStorage<string> = new Stack<string>();
+
+  perfLinearDS(stack);
+};

package/src/demo/performance/sort-compare.ts

@@ -0,0 +1,60 @@
+import { FnSort } from "../../types/FnSort";
+import { mergeSort } from "../../algorithms/sorts/merge-sort";
+import { insertionSort } from "../../algorithms/sorts/insertion-sort";
+import { bubbleSort } from "../../algorithms/sorts/bubble-sort";
+import { quickSort } from "../../algorithms/sorts/quick-sort";
+import { selectSort } from "../../algorithms/sorts/select-sort";
+import { perf } from "../../utils";
+
+export const randomizeArray = (length: number, max: number): Array<number> =>
+  new Array(length).fill(0).map(() => Math.round(Math.random() * max));
+
+export const sortCompare = (
+  sortFn: FnSort,
+  n: number,
+  callsNumber: number
+): void => {
+  let totalTime = 0;
+
+  for (let i = 0; i < callsNumber; i++) {
+    const generatedArr = randomizeArray(n, 1000);
+    const perfResult = perf(() => {
+      sortFn(generatedArr);
+    });
+    totalTime += perfResult;
+  }
+
+  const averageTime = totalTime / callsNumber;
+
+  console.log(`N: ${n} = ${averageTime}ms`);
+};
+
+export const sortCompareRunner = (
+  sortFn: FnSort,
+  callsNumber: number
+): void => {
+  sortCompare(sortFn, 5, callsNumber);
+  sortCompare(sortFn, 50, callsNumber);
+  sortCompare(sortFn, 500, callsNumber);
+  sortCompare(sortFn, 5000, callsNumber);
+  sortCompare(sortFn, 50000, callsNumber);
+};
+
+export const compareAllSortTypes = (): void => {
+  const callsNumber = 10;
+
+  console.log(`MERGE SORT:`);
+  sortCompareRunner(mergeSort, callsNumber);
+
+  console.log(`QUICK SORT:`);
+  sortCompareRunner(quickSort, callsNumber);
+
+  console.log(`SELECTION SORT:`);
+  sortCompareRunner(selectSort, callsNumber);
+
+  console.log(`BUBBLE SORT:`);
+  sortCompareRunner(bubbleSort, callsNumber);
+
+  console.log(`INSERTION SORT:`);
+  sortCompareRunner(insertionSort, callsNumber);
+};

package/src/exports/algotirhms.ts

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

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

package/src/exports/helpers.ts

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

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

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

@@ -0,0 +1,53 @@
+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/src/exports/utils.ts

@@ -0,0 +1,21 @@
+import { memoize } from "../algorithms/memoize";
+import {
+  getMinIndex,
+  getMinIndexFromIndex,
+  perf,
+  randomizeNumberInRange,
+  roundNumber,
+  swapArrayItems,
+  perfAsync,
+} from "../utils";
+
+export {
+  perf,
+  getMinIndex,
+  getMinIndexFromIndex,
+  memoize,
+  perfAsync,
+  roundNumber,
+  randomizeNumberInRange,
+  swapArrayItems,
+};

package/src/helpers/createBinaryTree.ts

@@ -0,0 +1,24 @@
+import { EnumBinarySearchTreeType } from "../types/EnumBinarySearchTreeType";
+import BinarySearchTree from "../data-structures/BinaryTree/BinarySearchTree/BinarySearchTree";
+import RandBinarySearchTree from "../data-structures/BinaryTree/RandBinarySearchTree/RandBinarySearchTree";
+import IBinaryTree from "../types/IBinaryTree";
+
+/**
+ * Returns binary tree by type
+ */
+export const createBinaryTree = <T>(
+  type: EnumBinarySearchTreeType
+): IBinaryTree<T> => {
+  let binaryTree: IBinaryTree<T>;
+
+  switch (type) {
+    case EnumBinarySearchTreeType.BST:
+      binaryTree = new BinarySearchTree();
+      break;
+    case EnumBinarySearchTreeType.RANDOMIZED_BST:
+      binaryTree = new RandBinarySearchTree();
+      break;
+  }
+
+  return binaryTree;
+};

package/src/helpers/createGraph.ts

@@ -0,0 +1,24 @@
+import IGraph from "../types/IGraph";
+import DirectedGraph from "../data-structures/Graph/DirectedGraph";
+import UndirectedGraph from "../data-structures/Graph/UndirectedGraph";
+import { EnumGraphType } from "../types/EnumGraphType";
+
+/**
+ * Returns graph by type
+ */
+export const createGraph = <T>(type: EnumGraphType): IGraph<T> => {
+  let graph: IGraph<T>;
+
+  switch (type) {
+    case EnumGraphType.Directed:
+      graph = new DirectedGraph();
+      break;
+    case EnumGraphType.Undirected:
+      graph = new UndirectedGraph();
+      break;
+    default:
+      throw new Error("Invalid graph type");
+  }
+
+  return graph;
+};

package/src/helpers/createGraphFromMatrix.ts

@@ -0,0 +1,47 @@
+import IGraph from "../types/IGraph";
+import { EnumGraphType } from "../types/EnumGraphType";
+import { ArrayMatrix } from "../types/ArrayMatrix";
+import { createGraph } from "./createGraph";
+import { EDGE_EXISTS_STATE } from "../constants";
+
+/**
+ * Creates a graph from N*N matrix that contains 1 in case of edge exists or 0 in case it does not
+ */
+export const createGraphFromMatrix = <T>(
+  matrix: ArrayMatrix,
+  fieldsList: Array<T>,
+  type: EnumGraphType
+): IGraph<T> => {
+  const graph: IGraph<T> = createGraph(type);
+
+  fieldsList.forEach((fieldName) => {
+    graph.addVertex(fieldName);
+  });
+
+  matrix.forEach((row: Array<number>, rowIndex: number) => {
+    row.forEach((col: number, colIndex: number) => {
+      const rowColState = matrix[rowIndex][colIndex];
+      const colRowState = matrix[colIndex][rowIndex];
+
+      if (type === EnumGraphType.Undirected) {
+        if (
+          rowColState === EDGE_EXISTS_STATE &&
+          colRowState === EDGE_EXISTS_STATE
+        ) {
+          graph.addEdge(fieldsList[rowIndex], fieldsList[colIndex]);
+        }
+      }
+
+      if (type === EnumGraphType.Directed) {
+        if (rowColState === EDGE_EXISTS_STATE) {
+          graph.addEdge(fieldsList[rowIndex], fieldsList[colIndex]);
+        }
+        if (colRowState === EDGE_EXISTS_STATE) {
+          graph.addEdge(fieldsList[colIndex], fieldsList[rowIndex]);
+        }
+      }
+    });
+  });
+
+  return graph;
+};

package/src/helpers/createLinkedList.ts

@@ -0,0 +1,24 @@
+import { EnumLinkedListType } from "../types/EnumLinkedListType";
+import DoubleLinkedList from "../data-structures/LinkedList/DoubleLinkedList/DoubleLinkedList";
+import SingleLinkedList from "../data-structures/LinkedList/SingleLinkedList/SingleLinkedList";
+import ILinkedList from "../types/ILinkedList";
+
+export const createLinkedList = <T>(
+  type: EnumLinkedListType,
+  capacity?: number
+): ILinkedList<T> => {
+  let linkedList: ILinkedList<T>;
+
+  switch (type) {
+    case EnumLinkedListType.DOUBLE:
+      linkedList = new DoubleLinkedList(capacity);
+      break;
+    case EnumLinkedListType.SINGLE:
+      linkedList = new SingleLinkedList(capacity);
+      break;
+    default:
+      throw new Error("Invalid list type");
+  }
+
+  return linkedList;
+};

package/src/index.ts

@@ -0,0 +1,40 @@
+/**
+ * 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();

package/src/types/ArrayMatrix.ts

@@ -0,0 +1 @@
+export type ArrayMatrix = Array<Array<number>>;

package/src/types/EnumBinarySearchTreeType.ts

@@ -0,0 +1,4 @@
+export enum EnumBinarySearchTreeType {
+  BST = "Binary Search Tree",
+  RANDOMIZED_BST = "Randomized Binary Search Tree",
+}

package/src/types/EnumGraphTraversalType.ts

@@ -0,0 +1,5 @@
+export enum EnumGraphTraversalType {
+  BFS = "Breadth first traversal",
+  DFS = "Deep first traversal",
+  DIJKSTRA = "Dijkstra traversal",
+}

package/src/types/EnumGraphType.ts

@@ -0,0 +1,4 @@
+export enum EnumGraphType {
+  Directed = "Directed",
+  Undirected = "Undirected",
+}

package/src/types/EnumLinkedListType.ts

@@ -0,0 +1,4 @@
+export enum EnumLinkedListType {
+  DOUBLE = "Double linked list",
+  SINGLE = "Single linked list",
+}

package/src/types/EnumRandomGenerationFormat.ts

@@ -0,0 +1,4 @@
+export enum EnumRandomGenerationFormat {
+  Numbers = "NUMBERS",
+  Hash = "HASH",
+}

package/src/types/EnumSortType.ts

@@ -0,0 +1,7 @@
+export enum EnumSortType {
+  Quick = "Quick",
+  Merge = "Merge",
+  Selection = "Selection",
+  Bubble = "Bubble",
+  Insertion = "Insertion",
+}

package/src/types/EnumTreeTraversalType.ts

@@ -0,0 +1,5 @@
+export enum EnumTreeTraversalType {
+  InOrder = "InOrder",
+  PreOrder = "PreOrder",
+  PostOrder = "PostOrder",
+}

package/src/types/FnCompareTwo.ts

@@ -0,0 +1 @@
+export type FnCompareTwo<T> = (firstItem: T, secondItem: T) => boolean;

package/src/types/FnSort.ts

@@ -0,0 +1 @@
+export type FnSort = (arg: Array<number>) => Array<number>;

package/src/types/FnToMemoize.ts

@@ -0,0 +1 @@
+export type FnToMemoize<Key, Value> = (...args: Array<Key>) => Value;

package/src/types/IArrayFacade.ts

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

package/src/types/IBiDirectIterable.ts

@@ -0,0 +1,6 @@
+import IBiDirectIterator from "./IBiDirectIterator";
+import IIterable from "./IIterable";
+
+export default interface IBiDirectIterable<T> extends IIterable<T> {
+  iterator(fromIndex?: number): IBiDirectIterator<T>;
+}

package/src/types/IBiDirectIterator.ts

@@ -0,0 +1,12 @@
+import IIterator from "./IIterator";
+
+export default interface IBiDirectIterator<T> extends IIterator<T> {
+  /**
+   * Will do one iteration back and returns prev item value
+   */
+  prev(): T;
+  /**
+   * Check if next element exists
+   */
+  hasPrev(): boolean;
+}

package/src/types/IBinaryTree.ts

@@ -0,0 +1,13 @@
+import { EnumTreeTraversalType } from "./EnumTreeTraversalType";
+
+export default interface IBinaryTree<T> {
+  has(value: T): boolean;
+  insert(value: T): void;
+  delete(value: T): void;
+  subtree(value: T): IBinaryTree<T>;
+  max(): T;
+  min(): T;
+  length(): number;
+  height(): number;
+  traverse(type: EnumTreeTraversalType): Array<T>;
+}

package/src/types/IConvertableToArray.ts

@@ -0,0 +1,4 @@
+export default interface IConvertableToArray<T> {
+  pushFromArray(elements: Array<T>): void;
+  getAsArray(): Array<T>;
+}

package/src/types/IGraph.ts

@@ -0,0 +1,16 @@
+export default interface IGraph<T> {
+  weight(): number;
+  vertices(): Array<T>;
+  verticesCount(): number;
+  edgesCount(): number;
+
+  addVertex(data: T): this;
+  removeVertex(data: T): this;
+  hasVertex(data: T): boolean;
+  getVertexNeighbors(data: T): Array<T>;
+
+  addEdge(from: T, to: T, weight?: number): this;
+  removeEdge(from: T, to: T): this;
+  hasEdge(from: T, to: T): boolean;
+  getEdgeWeight(from: T, to: T): number;
+}

package/src/types/IGraphCreator.ts

@@ -0,0 +1,5 @@
+import IGraph from "./IGraph";
+
+export default interface IGraphCreator<T> {
+  createGraph(): IGraph<T>;
+}

package/src/types/IGraphIterationStrategy.ts

@@ -0,0 +1,6 @@
+import IGraph from "./IGraph";
+import IGraphIterator from "./IGraphIterator";
+
+export default interface IGraphIterationStrategy<T> {
+  createIterator(graph: IGraph<T>): IGraphIterator<T>;
+}

package/src/types/IGraphIterator.ts

@@ -0,0 +1,13 @@
+import IIterator from "./IIterator";
+
+export default interface IGraphIterator<T> extends IIterator<T> {
+  /**
+   * Get path which passed by iterator between two vertices
+   */
+  getPath(from: T, to: T): Array<T>;
+
+  /**
+   * Initialize iterator by passing start vertex
+   */
+  initIterator(from: T): void;
+}

package/src/types/IIterable.ts

@@ -0,0 +1,5 @@
+import IIterator from "./IIterator";
+
+export default interface IIterable<T> {
+  iterator(fromIndex?: number): IIterator<T>;
+}