@raikuxq/alg-ds 1.0.2 → 1.1.2

package/.idea/algorythmes.iml

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

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

package/.idea/deployment.xml

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

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

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

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

package/.idea/modules.xml

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

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

package/README.md

@@ -30,6 +30,7 @@ Clone this repository and install dependencies by using `yarn` command.
   + [Stack](#stack)
   + [Queue](#queue)
 + [Non-linear data structures](#non-linear-data-structures)
+  + [Hash table](#hash-table)
   + [Graph](#graph)
   + [Binary tree](#binary-trees)
 
@@ -135,6 +136,17 @@ Extends [IConvertableToArray](src/types/IConvertableToArray.ts) interface.
 
 # Non linear data structures
 
+## Hash Table
+### Interfaces
+[IKeyValueStorage](src/types/IKeyValueStorage.ts) — Contains basic key-value storages operations.
+
+### Implementation
+[HashTableNode](src/data-structures/HashTable/HashTableNode.ts) — Contains key, data and isDeleted properties.
+
+[HashTable](src/data-structures/HashTable/HashTable.ts)  [ [ tests ] ](test/unit/data-structures/hash-table/hash-table.test.ts) — Implementation of open addressing hash table using quadratic probing
+
+
+
 ## Graph
 ### Interfaces
 [IGraph](src/types/IGraph.ts) — Contains basic graph operations.

package/lib/algotirhms.ts

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

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

package/lib/data-structures.ts

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

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

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

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

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

package/package.json

@@ -4,7 +4,7 @@
     "test": "jest",
     "dev": "nodemon",
     "build": "rimraf ./build && tsc",
-    "start": "npm run build && node build/main.js",
+    "start": "npm run build && node --experimental-specifier-resolution=node .build/index.js",
     "lint": "yarn eslint . --ext .ts",
     "lint:fix": "yarn eslint --fix .  --ext .ts"
   },
@@ -26,10 +26,11 @@
     "prettier": "^2.1.2",
     "rimraf": "^3.0.2",
     "ts-jest": "^26.4.1",
-    "ts-node": "^8.10.2",
+    "ts-node": "^10.7.0",
+    "ts-node-esm": "^0.0.6",
     "typescript": "^4.0.3"
   },
   "dependencies": {},
-  "version": "1.0.2",
+  "version": "1.1.2",
   "type": "module"
 }

package/src/data-structures/HashTable/HashTable.ts

@@ -0,0 +1,202 @@
+import IKeyValueStorage from "../../types/IKeyValueStorage";
+import HashTableNode from "./HashTableNode";
+
+/**
+ * Implementation of open addressing hash table using quadratic probing
+ */
+export default class HashTable<T> implements IKeyValueStorage<T> {
+  /**
+   Constants
+   */
+  private static DEFAULT_MAX_CAPACITY = 100;
+  private static MAX_LOAD_FACTOR = 0.5;
+
+  /**
+   * State
+   */
+  private storage: Array<HashTableNode<T>>;
+  private maxCapacity: number;
+  private storageCapacity = 0;
+
+  /**
+   * Given init capacity size will be used
+   * @throws when initial capacity value is not larger than 0
+   */
+  public constructor(initialCapacity: number = HashTable.DEFAULT_MAX_CAPACITY) {
+    if (initialCapacity <= 0) {
+      throw new Error("Size must be larger than 0");
+    }
+    this.maxCapacity = initialCapacity;
+    this.storage = new Array(this.maxCapacity).fill(null);
+  }
+
+  /**
+   * Main-hash function
+   */
+  private hashFn(key: string, number: number): number {
+    return (
+      (this.innerHashFn(key) + 127 * number + 365 * number * number) %
+      this.maxCapacity
+    );
+  }
+
+  /**
+   * Helper-hash function
+   */
+  private innerHashFn(key: string): number {
+    const length: number = key.length;
+
+    if (length === 0) {
+      return 0;
+    }
+    const substring = key.substring(0, length - 1);
+    const symbol = key.charCodeAt(length - 1);
+
+    return (127 * this.innerHashFn(substring) + symbol) % this.maxCapacity;
+  }
+
+  /**
+   * Max capacity will be increased and storage will be overwritten
+   */
+  private resizeStorage(): Array<HashTableNode<T>> {
+    this.maxCapacity *= 2;
+
+    const newArray = new Array(this.maxCapacity).fill(null);
+
+    for (let i = 0; i < this.storage.length; i++) {
+      const element = this.storage[i];
+
+      if (element != null) {
+        for (let j = 0; j < this.maxCapacity; j++) {
+          const newIndex = this.hashFn(element.key, j);
+
+          if (newArray[newIndex] == null) {
+            newArray[newIndex] = element;
+
+            break;
+          }
+        }
+      }
+    }
+
+    return newArray;
+  }
+
+  /**
+   * Will find node instance by its key
+   * @throws when element does not exist
+   */
+  private findNode(key: string): HashTableNode<T> {
+    for (let i = 0; i < this.maxCapacity; i++) {
+      const index = this.hashFn(key, i);
+      const node = this.storage[index];
+
+      if (node?.key === key) {
+        if (node?.isDeleted) {
+          break;
+        }
+        return node;
+      }
+    }
+
+    throw new Error("Element does not exist");
+  }
+
+  /**
+   * Will create new node instance and set in to storage by index
+   */
+  private addNode(key: string, data: T, index: number): void {
+    this.storage[index] = new HashTableNode<T>(key, data);
+
+    this.storageCapacity++;
+    const loadFactor = this.storageCapacity / this.maxCapacity;
+
+    if (loadFactor >= HashTable.MAX_LOAD_FACTOR) {
+      this.storage = this.resizeStorage();
+    }
+  }
+
+  /**
+   * Will create new node instance and set in to storage by index
+   */
+  private updateNode(data: T, index: number): void {
+    this.storage[index].data = data;
+    this.storage[index].isDeleted = false;
+  }
+
+  /**
+   * Will insert item to hash table
+   */
+  public set(key: string, data: T): void {
+    for (let i = 0; i < this.maxCapacity; i++) {
+      const index = this.hashFn(key, i);
+      const node = this.storage[index];
+
+      const shouldAddNode = node === null;
+      if (shouldAddNode) {
+        this.addNode(key, data, index);
+        break;
+      }
+
+      const shouldUpdateNode = node.key === key;
+      if (shouldUpdateNode) {
+        this.updateNode(data, index);
+        break;
+      }
+    }
+  }
+
+  /**
+   * Will update item property isDeleted to false
+   * @throws when element does not exist
+   */
+  public delete(key: string): void {
+    for (let i = 0; i < this.maxCapacity; i++) {
+      const index = this.hashFn(key, i);
+
+      if (this.storage[index] !== null) {
+        this.storage[index].isDeleted = true;
+        return;
+      }
+    }
+
+    throw new Error("Element does not exist");
+  }
+
+  /**
+   * Will find item in hash table
+   * @throws when element does not exist
+   */
+  public get(key: string): T {
+    return this.findNode(key).data;
+  }
+
+  /**
+   * Check if node with given key exists
+   */
+  public has(key: string): boolean {
+    try {
+      return Boolean(this.findNode(key));
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /**
+   * Added elements count
+   */
+  public length(): number {
+    const actualItems = this.storage.filter((item) => {
+      return item !== null && !item.isDeleted;
+    });
+
+    return actualItems.length;
+  }
+
+  /**
+   * Will overwrite storage with array of null elements
+   */
+  public clear(): void {
+    this.storage = new Array(HashTable.DEFAULT_MAX_CAPACITY).fill(null);
+  }
+}

package/src/data-structures/HashTable/HashTableNode.ts

@@ -0,0 +1,31 @@
+export default class HashTableNode<T> {
+  private readonly _key: string;
+  private _data: T;
+  private _isDeleted: boolean;
+
+  public constructor(key: string, data: T) {
+    this._key = key;
+    this._data = data;
+    this._isDeleted = false;
+  }
+
+  get data(): T {
+    return this._data;
+  }
+
+  set data(value: T) {
+    this._data = value;
+  }
+
+  get key(): string {
+    return this._key;
+  }
+
+  get isDeleted(): boolean {
+    return this._isDeleted;
+  }
+
+  set isDeleted(value: boolean) {
+    this._isDeleted = value;
+  }
+}

package/src/demo/demo.hashtable.ts

@@ -0,0 +1,28 @@
+import HashTable from "../data-structures/HashTable/HashTable";
+
+export const demoHashtable = (): void => {
+  const hashTable = new HashTable<number>(15);
+
+  // emulate 66% load
+  for (let i = 0; i < 10; i++) {
+    hashTable.set(`key${i * 2}`, i * 2);
+  }
+  console.log(hashTable);
+
+  for (let i = 10; i < 15; i++) {
+    hashTable.set(`key${i * 2}`, i * 2);
+  }
+  console.log(hashTable);
+  console.log("\n length:", hashTable.length());
+
+  hashTable.set("key4", 10000);
+  console.log("\n", hashTable.get("key4"));
+  hashTable.delete("key4");
+  console.log("\n has key4:", hashTable.has("key4"));
+  hashTable.set("key4", 20000);
+  console.log("\n has key4:", hashTable.has("key4"));
+  console.log("\n key4 value:", hashTable.get("key4"));
+  console.log("\n", hashTable);
+  hashTable.clear();
+  console.log("\n", hashTable);
+};

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

@@ -1,9 +1,6 @@
 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");
@@ -22,7 +19,7 @@ export const bstCompare = (): void => {
 
   const arraySrc = Array.from(Array(1000).keys());
 
-  arraySrc.forEach((num, index) => {
+  arraySrc.forEach((num) => {
     bstLeaf.insert(num);
     bstRand.insert(num);
   });

package/src/demo/performance/hash-table.compare.ts

@@ -0,0 +1,40 @@
+import { perf, roundNumber } from "../../utils";
+import IKeyValueStorage from "../../types/IKeyValueStorage";
+import HashTable from "../../data-structures/HashTable/HashTable";
+
+export const pushToStorage = (
+  linearDS: IKeyValueStorage<number>,
+  elementsCount: number
+): void => {
+  for (let i = 0; i < elementsCount; i++) {
+    linearDS.set(`key${i}`, i);
+  }
+};
+
+export const perfHashTable = (): void => {
+  console.log(`HASHTABLE PERFORMANCE TEST:`);
+  const hashTable: IKeyValueStorage<number> = new HashTable<number>();
+  let elementsCount = 50;
+
+  while (elementsCount <= 5000000) {
+    pushToStorage(hashTable, elementsCount);
+
+    const perfSet = perf(() => {
+      hashTable.set(`key${elementsCount}`, elementsCount);
+    });
+    const perfGet = perf(() => {
+      hashTable.get(`key${elementsCount}`);
+    });
+
+    const perfHas = perf(() => {
+      hashTable.has(`key${elementsCount - 10}`);
+    });
+
+    console.log(`N: ${elementsCount} set: ${roundNumber(perfSet)}ms`);
+    console.log(`N: ${elementsCount} get: ${roundNumber(perfGet)}ms`);
+    console.log(`N: ${elementsCount} has: ${roundNumber(perfHas)}ms`);
+    console.log("=========================");
+
+    elementsCount *= 10;
+  }
+};