@raikuxq/alg-ds 1.1.2 → 1.1.5

package/src/data-structures/Graph/iterator/GraphIteratorDFS.ts

@@ -1,60 +0,0 @@
-import Stack from "../../Stack/Stack";
-import IGraph from "../../../types/IGraph";
-import AbstractGraphIterator from "./AbstractGraphIterator";
-
-/**
- * Deep first graph traversal
- */
-export default class GraphIteratorDFS<T> extends AbstractGraphIterator<T> {
-  private readonly stack: Stack<T>;
-
-  /**
-   * @inheritDoc
-   */
-  public constructor(graph: IGraph<T>) {
-    super(graph);
-    this.stack = new Stack();
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public hasNextImpl(): boolean {
-    return !this.stack.isEmpty();
-  }
-
-  /**
-   @inheritDoc
-   */
-  public initIteratorImpl(startVertex: T): void {
-    this.stack.push(startVertex);
-    this.visited.set(startVertex, true);
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public currentImpl(): T {
-    return this.stack.peek();
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public nextImpl(): T {
-    const next = this.stack.pop();
-    const nextNeighbors = this.graph.getVertexNeighbors(next);
-
-    nextNeighbors.forEach((neighbor) => {
-      const isNotVisited = !this.visited.get(neighbor);
-
-      if (isNotVisited) {
-        this.stack.push(neighbor);
-        this.visited.set(neighbor, true);
-        this.parents.set(neighbor, next);
-      }
-    });
-
-    return next;
-  }
-}

package/src/data-structures/Graph/iterator/GraphIteratorDijkstra.ts

@@ -1,94 +0,0 @@
-import IGraph from "../../../types/IGraph";
-import AbstractGraphIterator from "./AbstractGraphIterator";
-
-/**
- * Dijkstra method graph traversal
- */
-export default class GraphIteratorDijkstra<T> extends AbstractGraphIterator<T> {
-  private readonly costs: Map<T, number>;
-
-  /**
-   * @inheritDoc
-   */
-  public constructor(graph: IGraph<T>) {
-    super(graph);
-    this.costs = new Map();
-  }
-
-  /**
-   * Get not visited vertex with minimal cost
-   */
-  private getClosestNotVisited(): T {
-    const keys = Array.from(this.costs.keys());
-    const priorityList = keys
-      .filter((key: T) => !this.visited.get(key))
-      .sort((aKey: T, bKey: T) => {
-        const aCost = this.costs.get(aKey) || 0;
-        const bCost = this.costs.get(bKey) || 0;
-
-        return aCost - bCost;
-      });
-
-    if (priorityList[0] === undefined) {
-      throw new Error("No more vertices found");
-    }
-
-    return priorityList[0];
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public initIteratorImpl(startVertex: T): void {
-    if (!this.graph.hasVertex(startVertex)) {
-      throw new Error("Start vertex does not exist");
-    }
-
-    this.visited.set(startVertex, true);
-    this.costs.set(startVertex, 0);
-
-    this.graph.getVertexNeighbors(startVertex).forEach((neighbor: T) => {
-      const edgeWeight = this.graph.getEdgeWeight(startVertex, neighbor);
-      this.costs.set(neighbor, edgeWeight);
-      this.parents.set(neighbor, startVertex);
-    });
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public hasNextImpl(): boolean {
-    return !(this.getClosestNotVisited() === null);
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public currentImpl(): T {
-    return this.getClosestNotVisited();
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public nextImpl(): T {
-    const next = this.getClosestNotVisited();
-
-    this.visited.set(next, true);
-    const nextNeighbors = this.graph.getVertexNeighbors(next);
-    const nextCost = this.costs.get(next);
-
-    nextNeighbors.forEach((neighbor: T) => {
-      const edgeWeight = this.graph.getEdgeWeight(next, neighbor);
-      const currentNeighborCost = this.costs.get(neighbor) || Infinity;
-      const newNeighborCost = (nextCost || 0) + edgeWeight;
-
-      if (newNeighborCost < currentNeighborCost) {
-        this.costs.set(neighbor, newNeighborCost);
-        this.parents.set(neighbor, next);
-      }
-    });
-
-    return next;
-  }
-}

package/src/data-structures/Graph/presenter/presenterAdjacencyLists.ts

@@ -1,29 +0,0 @@
-import IGraph from "../../../types/IGraph";
-
-/**
- * Get graph adjacency list
- *
- * @example
- *
- * Directed graph:
- * - Bob [Maria]
- * - Maria [Bob, John]
- * - John []
- *
- * @example
- *
- * Undirected graph:
- * - Bob [Maria]
- * - Maria [Bob, John]
- * - John [Maria]
- **/
-export const presenterAdjacencyLists = <T>(
-  graph: IGraph<T>
-): Map<T, Array<T>> => {
-  return graph.vertices().reduce((map: Map<T, Array<T>>, vertex: T) => {
-    const neighbors = graph.getVertexNeighbors(vertex);
-    map.set(vertex, neighbors);
-
-    return map;
-  }, new Map());
-};

package/src/data-structures/Graph/searching/hasPath.ts

@@ -1,38 +0,0 @@
-import IGraph from "../../../types/IGraph";
-import IGraphIterator from "../../../types/IGraphIterator";
-import IGraphIterationStrategy from "../../../types/IGraphIterationStrategy";
-
-/**
- * Check if graph has a path between two vertices
- * @throws when start vertex was not found
- * @throws when end vertex was not found
- * @throws when there is no path between two vertices
- */
-export const hasPath = <T>(
-  graph: IGraph<T>,
-  from: T,
-  to: T,
-  strategy: IGraphIterationStrategy<T>
-): boolean => {
-  /* Validate */
-  if (!graph.hasVertex(from)) {
-    throw new Error("Start vertex was not found");
-  }
-  if (!graph.hasVertex(to)) {
-    throw new Error("End vertex was not found");
-  }
-
-  const iterator: IGraphIterator<T> = strategy.createIterator(graph);
-  iterator.initIterator(from);
-
-  /* Find target element */
-  while (iterator.hasNext()) {
-    const next = iterator.next();
-
-    if (next === to) {
-      return true;
-    }
-  }
-
-  return false;
-};

package/src/data-structures/Graph/searching/shortestPath.ts

@@ -1,38 +0,0 @@
-import IGraph from "../../../types/IGraph";
-import IGraphIterator from "../../../types/IGraphIterator";
-import IGraphIterationStrategy from "../../../types/IGraphIterationStrategy";
-
-/**
- * Find the shortest path between two vertices
- * @throws when start vertex was not found
- * @throws when end vertex was not found
- * @throws when there is no path between two vertices
- */
-export const shortestPath = <T>(
-  graph: IGraph<T>,
-  from: T,
-  to: T,
-  strategy: IGraphIterationStrategy<T>
-): Array<T> => {
-  /* Validate */
-  if (!graph.hasVertex(from)) {
-    throw new Error("Start vertex was not found");
-  }
-  if (!graph.hasVertex(to)) {
-    throw new Error("End vertex was not found");
-  }
-
-  const iterator: IGraphIterator<T> = strategy.createIterator(graph);
-  iterator.initIterator(from);
-
-  /* Find target element */
-  while (iterator.hasNext()) {
-    const next = iterator.next();
-
-    if (next === to) {
-      break;
-    }
-  }
-
-  return iterator.getPath(from, to);
-};

package/src/data-structures/Graph/strategy/BFSIterationStrategy.ts

@@ -1,11 +0,0 @@
-import IGraphIterationStrategy from "../../../types/IGraphIterationStrategy";
-import IGraphIterator from "../../../types/IGraphIterator";
-import IGraph from "../../../types/IGraph";
-import GraphIteratorBFS from "../iterator/GraphIteratorBFS";
-
-export default class BFSIterationStrategy<T>
-  implements IGraphIterationStrategy<T> {
-  public createIterator(graph: IGraph<T>): IGraphIterator<T> {
-    return new GraphIteratorBFS<T>(graph);
-  }
-}

package/src/data-structures/Graph/strategy/DFSIterationStrategy.ts

@@ -1,11 +0,0 @@
-import IGraph from "../../../types/IGraph";
-import IGraphIterationStrategy from "../../../types/IGraphIterationStrategy";
-import IGraphIterator from "../../../types/IGraphIterator";
-import GraphIteratorDFS from "../iterator/GraphIteratorDFS";
-
-export default class DFSIterationStrategy<T>
-  implements IGraphIterationStrategy<T> {
-  public createIterator(graph: IGraph<T>): IGraphIterator<T> {
-    return new GraphIteratorDFS(graph);
-  }
-}

package/src/data-structures/Graph/strategy/DijkstraIterationStrategy.ts

@@ -1,11 +0,0 @@
-import IGraph from "../../../types/IGraph";
-import IGraphIterationStrategy from "../../../types/IGraphIterationStrategy";
-import IGraphIterator from "../../../types/IGraphIterator";
-import GraphIteratorDijkstra from "../iterator/GraphIteratorDijkstra";
-
-export default class DijkstraIterationStrategy<T>
-  implements IGraphIterationStrategy<T> {
-  public createIterator(graph: IGraph<T>): IGraphIterator<T> {
-    return new GraphIteratorDijkstra(graph);
-  }
-}

package/src/data-structures/Graph/transposing/transposeDirectedGraph.ts

@@ -1,19 +0,0 @@
-import IGraph from "../../../types/IGraph";
-import { createGraphFromMatrix } from "../../../helpers/createGraphFromMatrix";
-import { EnumGraphType } from "../../../types/EnumGraphType";
-import { presenterAdjacencyMatrix } from "../presenter/presenterAdjacencyMatrix";
-import { transposeMatrix } from "../../../algorithms/transpose-matrix";
-
-export const transposeDirectedGraph = <T>(
-  sourceGraph: IGraph<T>
-): IGraph<T> => {
-  const verticesList = sourceGraph.vertices();
-  const matrix = presenterAdjacencyMatrix(sourceGraph);
-  const transposedMatrix = transposeMatrix(matrix);
-
-  return createGraphFromMatrix(
-    transposedMatrix,
-    verticesList,
-    EnumGraphType.Directed
-  );
-};

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

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

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