@raikuxq/alg-ds 1.1.2 → 1.1.5

package/src/data-structures/Graph/AbstractGraph.ts

@@ -1,189 +0,0 @@
-import GraphEdge from "./GraphEdge";
-
-export default abstract class AbstractGraph<T> {
-  protected _vertices: Map<T, Array<T>>;
-  protected _edges: Array<GraphEdge<T>>;
-
-  /**
-   * Created empty instance
-   */
-  protected constructor() {
-    this._vertices = new Map<T, Array<T>>();
-    this._edges = new Array<GraphEdge<T>>();
-  }
-
-  /**
-   * Find edge by its from and to vertices
-   */
-  protected abstract getEdgeByValue(from: T, to: T): GraphEdge<T>;
-
-  /**
-   * Get vertices list in array format
-   */
-  protected getVerticesArrayFormat(): Array<T> {
-    return Array.from(this._vertices.keys());
-  }
-
-  /**
-   * Find vertex in vertices list by its data
-   * @throws when vertex was not found
-   */
-  protected tryFindVertex(data: T): T {
-    const isExists = this._vertices.has(data);
-
-    if (!isExists) {
-      throw new Error("Vertex not found");
-    }
-
-    return data;
-  }
-
-  /**
-   * Update edge weight between from and to vertices
-   */
-  protected updateEdgeWeight(from: T, to: T, weight: number): void {
-    const edge = this.getEdgeByValue(from, to);
-
-    edge.weight = weight;
-  }
-
-  /**
-   * Will remove all vertex relations with others vertices
-   */
-  protected cascadeRemoveVertexRelations(vertexToRemove: T): void {
-    this.getVerticesArrayFormat().forEach((neighbor: T) => {
-      const neighborVertexNeighbors = this._vertices.get(neighbor);
-
-      if (neighborVertexNeighbors) {
-        const neighborVertexFilteredNeighbors = neighborVertexNeighbors.filter(
-          (newNeighbor: T) => newNeighbor !== vertexToRemove
-        );
-
-        this._vertices.set(neighbor, neighborVertexFilteredNeighbors);
-      }
-    });
-  }
-
-  /**
-   * Will remove all vertices edges with vertex to remove
-   */
-  protected cascadeRemoveVertexEdges(vertexToRemove: T): void {
-    this._edges = this._edges.filter((edge: GraphEdge<T>) => {
-      const shouldBeDeleted =
-        edge.toVertex === vertexToRemove || edge.fromVertex === vertexToRemove;
-
-      return !shouldBeDeleted;
-    });
-  }
-
-  /**
-   * Get sum of all graph edges
-   */
-  public weight(): number {
-    return this._edges.reduce(
-      (acc: number, edge: GraphEdge<T>) => acc + edge.weight,
-      0
-    );
-  }
-
-  /**
-   * Get array of vertices
-   */
-  public vertices(): Array<T> {
-    return this.getVerticesArrayFormat().map((vertex: T) => vertex);
-  }
-
-  /**
-   * Get vertices count
-   */
-  public verticesCount(): number {
-    return this.vertices().length;
-  }
-
-  /**
-   * Get edges count
-   */
-  public edgesCount(): number {
-    return this._edges.length;
-  }
-
-  /**
-   * Add vertex
-   * @throws when vertex is already exists
-   */
-  public addVertex(data: T): this {
-    if (this.hasVertex(data)) {
-      throw new Error("Vertex is already exist");
-    }
-
-    this._vertices.set(data, new Array<T>());
-
-    return this;
-  }
-
-  /**
-   * Remove vertex
-   * @throws when vertex is already does not exist
-   */
-  public removeVertex(data: T): this {
-    try {
-      const vertexToRemove = this.tryFindVertex(data);
-
-      this.cascadeRemoveVertexEdges(vertexToRemove);
-      this.cascadeRemoveVertexRelations(vertexToRemove);
-      this._vertices.delete(vertexToRemove);
-    } catch (e) {
-      throw new Error("Vertex does not exist already");
-    }
-
-    return this;
-  }
-
-  /**
-   * Add edge between two vertices
-   */
-  public abstract addEdge(from: T, to: T, weight?: number): this;
-
-  /**
-   * Remove edge between two vertices
-   */
-  public abstract removeEdge(from: T, to: T): this;
-
-  /**
-   * Get vertex neighbors by its data
-   */
-  public getVertexNeighbors(data: T): Array<T> {
-    const vertex = this.tryFindVertex(data);
-    return this._vertices.get(vertex) || [];
-  }
-
-  /**
-   * Check if graph has vertex
-   */
-  public hasVertex(data: T): boolean {
-    return this._vertices.has(data);
-  }
-
-  /**
-   * Check if graph has edge between from and to vertices
-   */
-  public hasEdge(from: T, to: T): boolean {
-    return Boolean(
-      this._edges.find((edge) => {
-        return edge.fromVertex === from && edge.toVertex === to;
-      })
-    );
-  }
-
-  /**
-   * Get edge weight between from and to vertices
-   */
-  public getEdgeWeight(from: T, to: T): number {
-    const fromVertex = this.tryFindVertex(from);
-    const toVertex = this.tryFindVertex(to);
-
-    const edge = this.getEdgeByValue(fromVertex, toVertex);
-
-    return edge.weight;
-  }
-}

package/src/data-structures/Graph/DirectedGraph.ts

@@ -1,84 +0,0 @@
-import AbstractGraph from "./AbstractGraph";
-import GraphEdge from "./GraphEdge";
-
-/**
- * Directed graph - data structure where edges with same pair of vertices are not equal
- * @example A-B is not the same as B-A
- */
-export default class DirectedGraph<T> extends AbstractGraph<T> {
-  /**
-   * @inheritDoc
-   */
-  public constructor() {
-    super();
-  }
-
-  /**
-   * @inheritDoc
-   */
-  protected getEdgeByValue(from: T, to: T): GraphEdge<T> {
-    const edge = this._edges.find(
-      (edge: GraphEdge<T>) => edge.fromVertex === from && edge.toVertex === to
-    );
-
-    if (!edge) {
-      throw new Error("Edge not found");
-    }
-
-    return edge;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public addEdge(from: T, to: T, weight?: number): this {
-    try {
-      const fromVertex = this.tryFindVertex(from);
-      const toVertex = this.tryFindVertex(to);
-
-      if (this.hasEdge(fromVertex, toVertex)) {
-        if (typeof weight === "number") {
-          this.updateEdgeWeight(fromVertex, toVertex, weight);
-        }
-      } else {
-        const edge = new GraphEdge(fromVertex, toVertex, weight);
-
-        this._edges.push(edge);
-        this._vertices.get(fromVertex)?.push(toVertex);
-      }
-    } catch {
-      throw new Error(
-        "Edge cannot be added because one of vertices was not found"
-      );
-    }
-
-    return this;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public removeEdge(from: T, to: T): this {
-    try {
-      const fromVertex = this.tryFindVertex(from);
-      const toVertex = this.tryFindVertex(to);
-      const edgeToRemove = this.getEdgeByValue(fromVertex, toVertex);
-
-      const fromVertexNeighbors = this._vertices.get(fromVertex) || [];
-      const fromNewNeighbors = fromVertexNeighbors.filter(
-        (vertex: T) => toVertex !== vertex
-      );
-
-      this._vertices.set(fromVertex, fromNewNeighbors);
-      this._edges = this._edges.filter(
-        (edge: GraphEdge<T>) => edge !== edgeToRemove
-      );
-    } catch {
-      throw new Error(
-        "Edge cannot be removed because one of vertices was not found"
-      );
-    }
-
-    return this;
-  }
-}

package/src/data-structures/Graph/GraphEdge.ts

@@ -1,33 +0,0 @@
-/**
- * Graph edge between two vertices
- */
-export default class GraphEdge<T> {
-  private readonly _fromVertex: T;
-  private readonly _toVertex: T;
-  private _weight: number;
-
-  /**
-   * Create instance with linked "from" and "to" vertices
-   */
-  public constructor(fromVertex: T, toVertex: T, weight = 0) {
-    this._fromVertex = fromVertex;
-    this._toVertex = toVertex;
-    this._weight = weight;
-  }
-
-  get fromVertex(): T {
-    return this._fromVertex;
-  }
-
-  get toVertex(): T {
-    return this._toVertex;
-  }
-
-  get weight(): number {
-    return this._weight;
-  }
-
-  set weight(value: number) {
-    this._weight = value;
-  }
-}

package/src/data-structures/Graph/UndirectedGraph.ts

@@ -1,108 +0,0 @@
-import AbstractGraph from "./AbstractGraph";
-import GraphEdge from "./GraphEdge";
-
-/**
- * Undirected graph - data structure where edges with same pair of vertices are equal
- * @example A-B is same as B-A
- */
-export default class UndirectedGraph<T> extends AbstractGraph<T> {
-  /**
-   * @inheritDoc
-   */
-  public constructor() {
-    super();
-  }
-
-  /**
-   * @inheritDoc
-   */
-  protected getEdgeByValue(from: T, to: T): GraphEdge<T> {
-    const edge = this._edges.find(
-      (edge: GraphEdge<T>) =>
-        (edge.fromVertex === from && edge.toVertex === to) ||
-        (edge.fromVertex === to && edge.toVertex === from)
-    );
-
-    if (!edge) {
-      throw new Error("Edge not found");
-    }
-
-    return edge;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public hasEdge(from: T, to: T): boolean {
-    return Boolean(
-      this._edges.find((edge) => {
-        return (
-          (edge.fromVertex === from && edge.toVertex === to) ||
-          (edge.fromVertex === to && edge.toVertex === from)
-        );
-      })
-    );
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public addEdge(from: T, to: T, weight?: number): this {
-    try {
-      const fromVertex = this.tryFindVertex(from);
-      const toVertex = this.tryFindVertex(to);
-
-      /** When edge is already exist, we should only update its weight */
-      if (this.hasEdge(fromVertex, toVertex)) {
-        if (typeof weight === "number") {
-          this.updateEdgeWeight(fromVertex, toVertex, weight);
-        }
-      } else {
-        const edge = new GraphEdge(fromVertex, toVertex, weight);
-
-        this._edges.push(edge);
-        this._vertices.get(fromVertex)?.push(toVertex);
-        this._vertices.get(toVertex)?.push(fromVertex);
-      }
-    } catch {
-      throw new Error(
-        "Edge cannot be added because one of vertices was not found"
-      );
-    }
-
-    return this;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public removeEdge(from: T, to: T): this {
-    try {
-      const fromVertex = this.tryFindVertex(from);
-      const toVertex = this.tryFindVertex(to);
-      const edgeToRemove = this.getEdgeByValue(fromVertex, toVertex);
-
-      const fromVertexNeighbors = this._vertices.get(fromVertex) || [];
-      const toVertexNeighbors = this._vertices.get(toVertex) || [];
-
-      const fromNewNeighbors = fromVertexNeighbors.filter(
-        (vertex: T) => toVertex !== vertex
-      );
-      const toNewNeighbors = toVertexNeighbors.filter(
-        (vertex: T) => fromVertex !== vertex
-      );
-
-      this._vertices.set(fromVertex, fromNewNeighbors);
-      this._vertices.set(toVertex, toNewNeighbors);
-      this._edges = this._edges.filter(
-        (edge: GraphEdge<T>) => edge !== edgeToRemove
-      );
-    } catch {
-      throw new Error(
-        "Edge cannot be removed because one of vertices was not found"
-      );
-    }
-
-    return this;
-  }
-}

package/src/data-structures/Graph/demo/generateRandomGraph.ts

@@ -1,93 +0,0 @@
-import IGraph from "../../../types/IGraph";
-import { EnumGraphType } from "../../../types/EnumGraphType";
-import { createGraph } from "../../../helpers/createGraph";
-import { randomizeNumberInRange } from "../../../utils";
-import { EnumRandomGenerationFormat } from "../../../types/EnumRandomGenerationFormat";
-
-const getRandomVertex = (): string => {
-  return "_" + Math.random().toString(36).substr(2, 9);
-};
-
-const getPossibleEdgesCount = (
-  type: EnumGraphType,
-  verticesCount: number
-): number => {
-  let possibleEdgesCount = verticesCount * (verticesCount - 1);
-
-  switch (type) {
-    case EnumGraphType.Directed: {
-      break;
-    }
-    case EnumGraphType.Undirected: {
-      possibleEdgesCount = Math.floor(possibleEdgesCount / 2);
-      break;
-    }
-    default: {
-      throw new Error("Wrong random generation format");
-    }
-  }
-
-  return possibleEdgesCount;
-};
-
-const fillGraphRandomly = (
-  graph: IGraph<string>,
-  format: EnumRandomGenerationFormat,
-  verticesCount: number
-): void => {
-  switch (format) {
-    case EnumRandomGenerationFormat.Hash: {
-      for (let i = 0; i < verticesCount; i++) {
-        graph.addVertex(getRandomVertex());
-      }
-      break;
-    }
-    case EnumRandomGenerationFormat.Numbers: {
-      for (let i = 0; i < verticesCount; i++) {
-        graph.addVertex((i + 1).toString());
-      }
-      break;
-    }
-    default: {
-      throw new Error("Wrong random generation format");
-    }
-  }
-};
-
-export const generateRandomGraph = (
-  verticesCount: number,
-  edgesCount: number,
-  type: EnumGraphType = EnumGraphType.Undirected,
-  format: EnumRandomGenerationFormat = EnumRandomGenerationFormat.Numbers
-): IGraph<string> => {
-  const graph = createGraph<string>(type);
-  const possibleEdgesCount = getPossibleEdgesCount(type, verticesCount);
-
-  if (edgesCount <= 0 || edgesCount > possibleEdgesCount) {
-    throw new Error(
-      `Edges count must be in range between 0 and ${possibleEdgesCount}`
-    );
-  }
-
-  fillGraphRandomly(graph, format, verticesCount);
-  const addedVertices = graph.vertices();
-  let addedEdgesCount = 0;
-
-  while (addedEdgesCount < edgesCount) {
-    const randomizeIndex = () => {
-      return randomizeNumberInRange(0, addedVertices.length);
-    };
-    const randomVertexFrom = addedVertices[randomizeIndex()];
-    const randomVertexTo = addedVertices[randomizeIndex()];
-
-    const isEdgeAlreadyExists = graph.hasEdge(randomVertexFrom, randomVertexTo);
-    const isTheSameVertex = randomVertexFrom === randomVertexTo;
-
-    if (!isTheSameVertex && !isEdgeAlreadyExists) {
-      graph.addEdge(randomVertexFrom, randomVertexTo);
-      addedEdgesCount++;
-    }
-  }
-
-  return graph;
-};

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

@@ -1,99 +0,0 @@
-import IGraphIterator from "../../../types/IGraphIterator";
-import IGraph from "../../../types/IGraph";
-
-export default abstract class AbstractGraphIterator<T>
-  implements IGraphIterator<T> {
-  protected readonly graph: IGraph<T>;
-  protected readonly visited: Map<T, boolean>;
-  protected readonly parents: Map<T, T>;
-
-  /**
-   * Creates empty instance
-   */
-  protected constructor(graph: IGraph<T>) {
-    this.graph = graph;
-    this.visited = new Map();
-    this.parents = new Map();
-  }
-
-  protected abstract currentImpl(): T;
-  protected abstract nextImpl(): T;
-  protected abstract initIteratorImpl(from: T): void;
-  protected abstract hasNextImpl(): boolean;
-
-  /**
-   * @inheritDoc
-   */
-  public initIterator(from: T): void {
-    if (!this.graph.hasVertex(from)) {
-      throw new Error("Start vertex does not exist");
-    }
-    this.initIteratorImpl(from);
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public hasNext(): boolean {
-    return this.hasNextImpl();
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public next(): T {
-    try {
-      if (!this.hasNext()) {
-        throw new Error();
-      }
-
-      return this.nextImpl();
-    } catch (e) {
-      throw new Error("Next element does not exist");
-    }
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public current(): T {
-    try {
-      const current = this.currentImpl();
-
-      if (current === null) {
-        throw new Error();
-      }
-      return current;
-    } catch (e) {
-      throw new Error("Current element does not exist");
-    }
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public getPath(from: T, to: T): Array<T> {
-    const path: Array<T> = new Array<T>();
-    const isLinkedDirectly = this.graph.hasEdge(from, to);
-    let currentVertex = this.parents.get(to);
-
-    if (isLinkedDirectly) {
-      return [from, to];
-    } else {
-      while (currentVertex) {
-        if (currentVertex === from) {
-          break;
-        }
-
-        path.push(currentVertex);
-        currentVertex = this.parents.get(currentVertex);
-      }
-
-      if (path.length === 0) {
-        throw new Error("There is no path found");
-      }
-
-      return [from, ...path.reverse(), to];
-    }
-  }
-}

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

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