@raikuxq/alg-ds 1.1.2 → 1.1.5

package/.idea/algorythmes.iml

@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="WEB_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
-      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
-      <excludeFolder url="file://$MODULE_DIR$/temp" />
-      <excludeFolder url="file://$MODULE_DIR$/tmp" />
-      <excludeFolder url="file://$MODULE_DIR$/build/coverage" />
-      <excludeFolder url="file://$MODULE_DIR$/coverage" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

package/.idea/codeStyles/codeStyleConfig.xml

@@ -1,5 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <state>
-    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
-  </state>
-</component>

package/.idea/deployment.xml

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="PublishConfigData">
-    <serverData>
-      <paths name="raikuhost">
-        <serverdata>
-          <mappings>
-            <mapping local="$PROJECT_DIR$" web="/" />
-          </mappings>
-        </serverdata>
-      </paths>
-    </serverData>
-  </component>
-</project>

package/.idea/inspectionProfiles/Project_Default.xml

@@ -1,7 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="DuplicatedCode" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
-    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
-  </profile>
-</component>

package/.idea/jsLinters/eslint.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="EslintConfiguration">
-    <option name="fix-on-save" value="true" />
-  </component>
-</project>

package/.idea/misc.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="JavaScriptSettings">
-    <option name="languageLevel" value="ES6" />
-  </component>
-</project>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/algorythmes.iml" filepath="$PROJECT_DIR$/.idea/algorythmes.iml" />
-    </modules>
-  </component>
-</project>

package/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>

package/lib/algotirhms.ts

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

package/lib/constants.ts

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

package/lib/data-structures.ts

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

package/lib/helpers.ts

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

package/lib/sorts.ts

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

package/lib/types.ts

@@ -1,53 +0,0 @@
-import { ArrayMatrix } from "../src/types/ArrayMatrix";
-import { EnumTreeTraversalType } from "../src/types/EnumTreeTraversalType";
-import { EnumBinarySearchTreeType } from "../src/types/EnumBinarySearchTreeType";
-import { EnumGraphTraversalType } from "../src/types/EnumGraphTraversalType";
-import { EnumGraphType } from "../src/types/EnumGraphType";
-import { EnumLinkedListType } from "../src/types/EnumLinkedListType";
-import { EnumRandomGenerationFormat } from "../src/types/EnumRandomGenerationFormat";
-import { EnumSortType } from "../src/types/EnumSortType";
-import { FnSort } from "../src/types/FnSort";
-import { FnCompareTwo } from "../src/types/FnCompareTwo";
-import { FnToMemoize } from "../src/types/FnToMemoize";
-import IArrayFacade from "../src/types/IArrayFacade";
-import IBiDirectIterator from "../src/types/IBiDirectIterator";
-import IBiDirectIterable from "../src/types/IBiDirectIterable";
-import IIterable from "../src/types/IIterable";
-import IIterator from "../src/types/IIterator";
-import IBinaryTree from "../src/types/IBinaryTree";
-import IConvertableToArray from "../src/types/IConvertableToArray";
-import IGraph from "../src/types/IGraph";
-import IGraphCreator from "../src/types/IGraphCreator";
-import IGraphIterationStrategy from "../src/types/IGraphIterationStrategy";
-import IGraphIterator from "../src/types/IGraphIterator";
-import ILinearStorage from "../src/types/ILinearStorage";
-import ILinearStorageRA from "../src/types/ILinearStorageRA";
-import ILinkedList from "../src/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/lib/utils.ts

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

package/src/algorithms/binary-search.ts

@@ -1,28 +0,0 @@
-/**
- * Find element's index in sorted array
- * Time complexity: O(log(n))
- */
-export const binarySearch = (
-  elements: Array<number>,
-  searchElement: number
-): number | null => {
-  const length: number = elements.length;
-
-  let leftIndex = 0;
-  let rightIndex: number = length - 1;
-
-  while (leftIndex <= rightIndex) {
-    const midIndex: number = Math.ceil((leftIndex + rightIndex) / 2);
-    const midEl: number = elements[midIndex];
-
-    if (searchElement == midEl) {
-      return midIndex;
-    } else if (midEl > searchElement) {
-      rightIndex = midIndex - 1;
-    } else if (midEl < searchElement) {
-      leftIndex = midIndex + 1;
-    }
-  }
-
-  return null;
-};

package/src/algorithms/factorial.ts

@@ -1,18 +0,0 @@
-import { memoize } from "./memoize";
-import { FnToMemoize } from "../types/FnToMemoize";
-
-/**
- * Time complexity: O(n!)
- */
-export const factorial = (x: number): number => {
-  return x > 1 ? x * factorial(x - 1) : x;
-};
-
-/**
- * Time complexity: O(n) - due to caching
- */
-export const memoizedFactorial: FnToMemoize<number, number> = memoize(
-  (n: number) => {
-    return n > 1 ? n * memoizedFactorial(n - 1) : n;
-  }
-);

package/src/algorithms/fibonacci.ts

@@ -1,18 +0,0 @@
-import { FnToMemoize } from "../types/FnToMemoize";
-import { memoize } from "./memoize";
-
-/**
- * Time complexity: O(n!)
- */
-export const fibonacci = (n: number): number => {
-  return n > 1 ? fibonacci(n - 1) + fibonacci(n - 2) : n;
-};
-
-/**
- * Time complexity: O(n) - due to caching
- */
-export const memoizedFibonacci: FnToMemoize<number, number> = memoize(
-  (n: number) => {
-    return n > 1 ? memoizedFibonacci(n - 1) + memoizedFibonacci(n - 2) : n;
-  }
-);

package/src/algorithms/memoize.ts

@@ -1,21 +0,0 @@
-import { FnToMemoize } from "../types/FnToMemoize";
-
-/**
- * Wrapper function that storing the results of calls and returning the cached result when the same inputs occur again
- */
-export const memoize = <Key, Value>(
-  fn: FnToMemoize<Key, Value>
-): FnToMemoize<Key, Value> => {
-  const cache = new Map<string, Value>();
-
-  return (...args: Array<Key>): Value => {
-    const jsonArgs = JSON.stringify(args);
-
-    if (!cache.has(jsonArgs)) {
-      const result = fn(...args);
-      cache.set(jsonArgs, result);
-    }
-
-    return <Value>cache.get(jsonArgs);
-  };
-};

package/src/algorithms/sorts/bubble-sort.ts

@@ -1,21 +0,0 @@
-import { swapArrayItems } from "../../utils";
-
-/**
- * Bubble sorting algorithm
- *
- * @description
- * Time complexity: Best O(n); Avg O(n \^ 2); Worst O(n \^ 2)
- * @description
- * Memory complexity: Worst case: O(1)
- */
-export const bubbleSort = (arr: Array<number>): Array<number> => {
-  for (let i = 0; i < arr.length - 1; i++) {
-    for (let j = 0; j < arr.length - 1; j++) {
-      if (arr[j] > arr[j + 1]) {
-        swapArrayItems(arr, j, j + 1);
-      }
-    }
-  }
-
-  return arr;
-};

package/src/algorithms/sorts/insertion-sort.ts

@@ -1,25 +0,0 @@
-import { swapArrayItems } from "../../utils";
-
-/**
- * Insertion sorting algorithm
- *
- * @description
- * Time complexity: Best O(n); Avg O(n \^ 2); Worst O(n \^ 2);
- * @description
- * Memory complexity: Worst case: O(1)
- */
-export const insertionSort = (arr: Array<number>): Array<number> => {
-  for (let i = 1; i < arr.length; i++) {
-    const current = arr[i];
-    let j = i - 1;
-
-    while (j >= 0 && arr[j] > current) {
-      swapArrayItems(arr, j + 1, j);
-      j--;
-    }
-
-    arr[j + 1] = current;
-  }
-
-  return arr;
-};

package/src/algorithms/sorts/merge-sort.ts

@@ -1,74 +0,0 @@
-/**
- * Merge two sorted arrays into one array
- */
-const merge = (
-  arr: Array<number>,
-  leftIndex: number,
-  midIndex: number,
-  rightIndex: number
-) => {
-  const container = arr.slice(leftIndex, rightIndex + 1);
-
-  let resultArrIndex = leftIndex;
-  let leftHalfIndex = leftIndex;
-  let rightHalfIndex = midIndex + 1;
-
-  /** While both halves of array are not ended */
-  while (leftHalfIndex <= midIndex && rightHalfIndex <= rightIndex) {
-    const leftHalfElement = container[leftHalfIndex - leftIndex];
-    const rightHalfElement = container[rightHalfIndex - leftIndex];
-
-    if (leftHalfElement < rightHalfElement) {
-      arr[resultArrIndex] = leftHalfElement;
-      leftHalfIndex++;
-    } else {
-      arr[resultArrIndex] = rightHalfElement;
-      rightHalfIndex++;
-    }
-    resultArrIndex++;
-  }
-
-  /** If one of halves is ended, the remaining one will just be pushed to result */
-  while (leftHalfIndex <= midIndex) {
-    arr[resultArrIndex] = container[leftHalfIndex - leftIndex];
-    resultArrIndex++;
-    leftHalfIndex++;
-  }
-  while (rightHalfIndex <= rightIndex) {
-    arr[resultArrIndex] = container[rightHalfIndex - leftIndex];
-    resultArrIndex++;
-    rightHalfIndex++;
-  }
-};
-
-/**
- * Divide array into 2 halves and merge them
- */
-const sortRange = (
-  arr: Array<number>,
-  leftIndex: number,
-  rightIndex: number
-) => {
-  if (rightIndex > leftIndex) {
-    const midIndex = Math.floor(leftIndex + (rightIndex - leftIndex) / 2);
-
-    sortRange(arr, leftIndex, midIndex);
-    sortRange(arr, midIndex + 1, rightIndex);
-
-    merge(arr, leftIndex, midIndex, rightIndex);
-  }
-};
-
-/**
- * Merge sorting algorithm
- *
- * @description
- * Time complexity: Best O(n * log(n)); Avg O(n * log(n)); Worst O(n * log(n))
- * @description
- * Memory complexity: Worst case: O(n)
- */
-export const mergeSort = (arr: Array<number>): Array<number> => {
-  sortRange(arr, 0, arr.length - 1);
-
-  return arr;
-};

package/src/algorithms/sorts/quick-sort.ts

@@ -1,54 +0,0 @@
-import { swapArrayItems } from "../../utils";
-
-/**
- * Quick sort algorithm
- *
- * @description
- * Time complexity: Best O(n * log(n)); Avg O(n * log(n)); Worst O(n  ^2)
- * @description
- * Memory complexity: Worst case: O(1)
- */
-export const quickSort = (arr: Array<number>): Array<number> => {
-  const partition = (
-    arr: Array<number>,
-    leftIndex: number,
-    rightIndex: number
-  ): number => {
-    const pivot = arr[leftIndex];
-
-    let leftWall = leftIndex;
-    let rightWall = rightIndex;
-
-    while (leftWall <= rightWall) {
-      while (arr[rightWall] > pivot) {
-        rightWall--;
-      }
-      while (arr[leftWall] < pivot) {
-        leftWall++;
-      }
-      if (leftWall <= rightWall) {
-        swapArrayItems(arr, leftWall, rightWall);
-        rightWall--;
-        leftWall++;
-      }
-    }
-
-    return leftWall;
-  };
-
-  const sort = (
-    arr: Array<number>,
-    leftIndex = 0,
-    rightIndex: number = arr.length - 1
-  ): Array<number> => {
-    if (leftIndex < rightIndex) {
-      const pivot = partition(arr, leftIndex, rightIndex);
-
-      sort(arr, leftIndex, pivot - 1);
-      sort(arr, pivot, rightIndex);
-    }
-    return arr;
-  };
-
-  return sort(arr);
-};

package/src/algorithms/sorts/select-sort.ts

@@ -1,19 +0,0 @@
-import { swapArrayItems, getMinIndexFromIndex } from "../../utils";
-
-/**
- * Selection sorting algorithm
- *
- * @description
- * Time complexity: Best O(n \^ 2); Avg O(n \^ 2); Worst O(n \^ 2)
- * @description
- * Memory complexity: Worst case: O(1)
- */
-export const selectSort = (arr: Array<number>): Array<number> => {
-  for (let index = 0; index < arr.length; index++) {
-    const minIndex: number = getMinIndexFromIndex(arr, index);
-
-    swapArrayItems<number>(arr, minIndex, index);
-  }
-
-  return arr;
-};

package/src/algorithms/transpose-matrix.ts

@@ -1,19 +0,0 @@
-import { ArrayMatrix } from "../types/ArrayMatrix";
-
-/**
- * Will flips a matrix over its diagonal
- */
-export const transposeMatrix = (matrix: ArrayMatrix): ArrayMatrix => {
-  /** Validation */
-  matrix.forEach((subArray) => {
-    const checkIsSameLength = subArray.length === matrix.length;
-    if (!checkIsSameLength) {
-      throw new Error("Given array is not a matrix");
-    }
-  });
-
-  return matrix.reduce((acc, current, currentIndex) => {
-    acc[currentIndex] = matrix.map((rowArr) => rowArr[currentIndex]);
-    return acc;
-  }, new Array(matrix.length));
-};

package/src/constants.ts

@@ -1,2 +0,0 @@
-export const EDGE_EXISTS_STATE = 1;
-export const EDGE_NOT_EXISTS_STATE = 0;

package/src/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryNode.ts

@@ -1,45 +0,0 @@
-export default abstract class AbstractBinaryNode<T> {
-  protected _data: T;
-  protected _left: AbstractBinaryNode<T> | null;
-  protected _right: AbstractBinaryNode<T> | null;
-  protected _parent: AbstractBinaryNode<T> | null;
-
-  protected constructor(initialData: T) {
-    this._data = initialData;
-    this._left = null;
-    this._right = null;
-    this._parent = null;
-  }
-
-  public get data(): T {
-    return this._data;
-  }
-
-  public set data(value: T) {
-    this._data = value;
-  }
-
-  public get left(): AbstractBinaryNode<T> | null {
-    return this._left;
-  }
-
-  public set left(value: AbstractBinaryNode<T> | null) {
-    this._left = value;
-  }
-
-  public get right(): AbstractBinaryNode<T> | null {
-    return this._right;
-  }
-
-  public set right(value: AbstractBinaryNode<T> | null) {
-    this._right = value;
-  }
-
-  public get parent(): AbstractBinaryNode<T> | null {
-    return this._parent;
-  }
-
-  public set parent(value: AbstractBinaryNode<T> | null) {
-    this._parent = value;
-  }
-}