@raikuxq/alg-ds 1.0.2 → 1.1.2

package/test/unit/data-structures/graph/graph.shortest-path.test.ts

@@ -1,207 +0,0 @@
-import AbstractGraph from "../../../../src/data-structures/Graph/AbstractGraph";
-import UndirectedGraph from "../../../../src/data-structures/Graph/UndirectedGraph";
-import DirectedGraph from "../../../../src/data-structures/Graph/DirectedGraph";
-import IGraphIterationStrategy from "../../../../src/types/IGraphIterationStrategy";
-import BFSIterationStrategy from "../../../../src/data-structures/Graph/strategy/BFSIterationStrategy";
-import DijkstraIterationStrategy from "../../../../src/data-structures/Graph/strategy/DijkstraIterationStrategy";
-
-import { shortestPath } from "../../../../src/data-structures/Graph/searching/shortestPath";
-import { EnumGraphTraversalType } from "../../../../src/types/EnumGraphTraversalType";
-
-describe("Shortest path algorithm", () => {
-  const strategy: IGraphIterationStrategy<string> = new BFSIterationStrategy();
-
-  describe("Any type of traversal in empty graph", () => {
-    const graph: AbstractGraph<string> = new UndirectedGraph();
-
-    it("should throw when graph is empty", () => {
-      expect(() => {
-        shortestPath(graph, "-", "-", strategy);
-      }).toThrowError();
-    });
-  });
-
-  describe("Any type of traversal in non empty graph", () => {
-    const graph: AbstractGraph<string> = new UndirectedGraph();
-
-    graph.addVertex("Mike").addVertex("Bob").addEdge("Mike", "Bob");
-
-    it("should throw when first node does not exist", () => {
-      expect(() => {
-        shortestPath(graph, "Mike", "NOT_EXISTED_NODE", strategy);
-      }).toThrowError();
-    });
-
-    it("should throw when second node does not exist", () => {
-      expect(() => {
-        shortestPath(graph, "NOT_EXISTED_NODE", "Bob", strategy);
-      }).toThrowError();
-    });
-
-    it("should find correct path between neighbor nodes", () => {
-      expect(shortestPath(graph, "Mike", "Bob", strategy)).toEqual([
-        "Mike",
-        "Bob",
-      ]);
-    });
-  });
-
-  describe.each([EnumGraphTraversalType.DIJKSTRA])(
-    "Weighted graph by %s",
-    (strategyType: EnumGraphTraversalType) => {
-      let strategy: IGraphIterationStrategy<string>;
-
-      switch (strategyType) {
-        case EnumGraphTraversalType.DIJKSTRA: {
-          strategy = new DijkstraIterationStrategy();
-          break;
-        }
-        default: {
-          throw new Error("Invalid search method");
-        }
-      }
-
-      describe("in undirected graph", () => {
-        const graph: AbstractGraph<string> = new UndirectedGraph();
-
-        graph
-          .addVertex("Mike")
-          .addVertex("Bob")
-          .addVertex("Lisa")
-          .addVertex("Aaron")
-          .addVertex("James")
-          .addVertex("Anna")
-          .addEdge("Mike", "Bob", 5)
-          .addEdge("Mike", "Lisa", 3)
-          .addEdge("Lisa", "Aaron", 3)
-          .addEdge("Lisa", "James", 3)
-          .addEdge("James", "Aaron", 3)
-          .addEdge("James", "Anna", 6)
-          .addEdge("Bob", "Anna", 15);
-
-        it("should find correct path between multiple nodes", () => {
-          /**
-           * Bob -> Mike (5) -> Anna (15) = 20
-           * Mike -> Lisa (3) -> James (3) -> Anna (6) = 12
-           */
-          expect(shortestPath(graph, "Mike", "Anna", strategy)).toEqual([
-            "Mike",
-            "Lisa",
-            "James",
-            "Anna",
-          ]);
-        });
-      });
-
-      describe("in directed graph", () => {
-        const graph: AbstractGraph<string> = new DirectedGraph();
-
-        graph
-          .addVertex("Mike")
-          .addVertex("Bob")
-          .addVertex("Lisa")
-          .addVertex("Aaron")
-          .addVertex("James")
-          .addVertex("Anna")
-          .addEdge("Mike", "Bob", 5)
-          .addEdge("Mike", "Lisa", 3)
-          .addEdge("Lisa", "Aaron", 3)
-          .addEdge("Aaron", "James", 3)
-          .addEdge("James", "Lisa", 10)
-          .addEdge("James", "Aaron", 10)
-          .addEdge("James", "Anna", 6)
-          .addEdge("Bob", "Anna", 15);
-
-        it("should find correct path between multiple nodes", () => {
-          /**
-           * Bob -> Mike (5) -> Anna (15) = 20
-           * Mike -> Lisa (3) -> Aaron (3) -> James (3) -> Anna (6) = 15
-           */
-          expect(shortestPath(graph, "Mike", "Anna", strategy)).toEqual([
-            "Mike",
-            "Lisa",
-            "Aaron",
-            "James",
-            "Anna",
-          ]);
-        });
-      });
-    }
-  );
-
-  describe.each([EnumGraphTraversalType.BFS])(
-    "Unweighted graph by %s",
-    (strategyType: EnumGraphTraversalType) => {
-      let strategy: IGraphIterationStrategy<string>;
-
-      switch (strategyType) {
-        case EnumGraphTraversalType.BFS: {
-          strategy = new BFSIterationStrategy();
-          break;
-        }
-        default: {
-          throw new Error("Invalid search method");
-        }
-      }
-
-      describe("in undirected graph", () => {
-        const graph: AbstractGraph<string> = new UndirectedGraph();
-
-        graph
-          .addVertex("Mike")
-          .addVertex("Bob")
-          .addVertex("Lisa")
-          .addVertex("Aaron")
-          .addVertex("James")
-          .addVertex("Anna")
-          .addEdge("Mike", "Bob")
-          .addEdge("Mike", "Aaron")
-          .addEdge("Mike", "Lisa")
-          .addEdge("Lisa", "James")
-          .addEdge("Lisa", "Aaron")
-          .addEdge("James", "Aaron")
-          .addEdge("James", "Anna")
-          .addEdge("Aaron", "Anna");
-
-        it("should find correct path between multiple nodes", () => {
-          /**
-           * Mike -> Aaron -> Lisa -> James -> Anna
-           * Mike -> Aaron -> Anna
-           * Mike -> Lisa -> James -> Anna
-           */
-          expect(shortestPath(graph, "Mike", "Anna", strategy)).toEqual([
-            "Mike",
-            "Aaron",
-            "Anna",
-          ]);
-        });
-      });
-
-      describe("in directed graph", () => {
-        const graph: AbstractGraph<string> = new DirectedGraph();
-
-        graph
-          .addVertex("Mike")
-          .addVertex("Bob")
-          .addVertex("Lisa")
-          .addVertex("Aaron")
-          .addVertex("James")
-          .addVertex("Anna")
-          .addEdge("Mike", "Bob")
-          .addEdge("Mike", "Lisa")
-          .addEdge("Lisa", "James")
-          .addEdge("James", "Aaron")
-          .addEdge("Aaron", "Anna")
-          .addEdge("Lisa", "Anna");
-
-        it("should find correct path between multiple nodes", () => {
-          expect(shortestPath(graph, "Mike", "Anna", strategy)).toEqual([
-            "Mike",
-            "Lisa",
-            "Anna",
-          ]);
-        });
-      });
-    }
-  );
-});

package/test/unit/data-structures/graph/graph.test.ts

@@ -1,394 +0,0 @@
-import IGraph from "../../../../src/types/IGraph";
-import UndirectedGraph from "../../../../src/data-structures/Graph/UndirectedGraph";
-import DirectedGraph from "../../../../src/data-structures/Graph/DirectedGraph";
-import { createGraph } from "../../../../src/helpers/createGraph";
-import { EnumGraphType } from "../../../../src/types/EnumGraphType";
-
-describe.each([EnumGraphType.Directed, EnumGraphType.Undirected])(
-  "%s graph",
-  (graphType: EnumGraphType) => {
-    describe("method weight", () => {
-      const graph: IGraph<string> = createGraph(graphType);
-
-      graph
-        .addVertex("Mike")
-        .addVertex("Bob")
-        .addVertex("Lisa")
-        .addEdge("Mike", "Bob", 5)
-        .addEdge("Bob", "Lisa", 10)
-        .addEdge("Mike", "Lisa", 20);
-
-      it("should return correct weight value", () => {
-        const weight = graph.weight();
-        const expectedWeight = 35;
-
-        expect(weight).toBe(expectedWeight);
-      });
-    });
-
-    describe("method verticesCount", () => {
-      describe("in empty graph", () => {
-        const graph: IGraph<string> = createGraph(graphType);
-
-        it("should return correct vertices count", () => {
-          expect(graph.verticesCount()).toBe(0);
-        });
-      });
-      describe("in non empty graph", () => {
-        const graph: IGraph<string> = createGraph(graphType);
-        graph.addVertex("Mike").addVertex("Bob").addVertex("Lisa");
-
-        it("should return correct vertices count", () => {
-          expect(graph.verticesCount()).toBe(3);
-        });
-      });
-    });
-
-    describe("method edgesCount", () => {
-      describe("in empty graph", () => {
-        const graph: IGraph<string> = createGraph(graphType);
-
-        it("should return correct vertices count", () => {
-          expect(graph.edgesCount()).toBe(0);
-        });
-      });
-
-      if (graphType === EnumGraphType.Undirected) {
-        describe("in non-empty graph", () => {
-          const graph: IGraph<string> = new UndirectedGraph();
-          graph
-            .addVertex("Mike")
-            .addVertex("Bob")
-            .addVertex("Lisa")
-            .addEdge("Mike", "Bob")
-            .addEdge("Mike", "Lisa")
-            .addEdge("Bob", "Lisa");
-
-          it("should return correct vertices count", () => {
-            expect(graph.edgesCount()).toBe(3);
-          });
-        });
-      }
-
-      if (graphType === EnumGraphType.Directed) {
-        describe("in non-empty graph", () => {
-          const graph: IGraph<string> = new DirectedGraph();
-          graph
-            .addVertex("Mike")
-            .addVertex("Bob")
-            .addVertex("Lisa")
-            .addEdge("Mike", "Bob")
-            .addEdge("Mike", "Lisa")
-            .addEdge("Lisa", "Mike");
-
-          it("should return correct vertices count", () => {
-            expect(graph.edgesCount()).toBe(3);
-          });
-        });
-      }
-    });
-
-    describe("method vertices", () => {
-      describe("in empty graph", () => {
-        const graph: IGraph<string> = createGraph(graphType);
-
-        it("should return empty array of vertices", () => {
-          expect(graph.vertices()).toEqual([]);
-        });
-      });
-      describe("in non empty graph", () => {
-        const graph: IGraph<string> = createGraph(graphType);
-        graph.addVertex("Mike").addVertex("Bob").addVertex("Lisa");
-
-        it("should return correct array of vertices", () => {
-          expect(graph.vertices()).toEqual(["Mike", "Bob", "Lisa"]);
-        });
-      });
-    });
-
-    describe("method addVertex", () => {
-      it("should correct add vertex", () => {
-        const graph: IGraph<string> = createGraph(graphType);
-        graph.addVertex("Mike").addVertex("Bob").addVertex("Lisa");
-
-        const vertices = graph.vertices();
-        const expectedVertices = ["Mike", "Bob", "Lisa"];
-
-        expect(vertices).toEqual(expectedVertices);
-      });
-      it("should throw when try to add an existed vertex", () => {
-        const graph: IGraph<string> = createGraph(graphType);
-        graph.addVertex("Mike");
-
-        expect(() => {
-          graph.addVertex("Mike");
-        }).toThrowError();
-      });
-    });
-
-    describe("method addEdge", () => {
-      describe("should throw when try to add edge between not existed vertices", () => {
-        const graph: IGraph<string> = createGraph(graphType);
-        graph.addVertex("Mike").addVertex("Bob");
-
-        it("when first node does not exist", () => {
-          expect(() => {
-            graph.addEdge("NOT_EXISTED_NODE", "Bob");
-          }).toThrowError();
-        });
-        it("when second node does not exist", () => {
-          expect(() => {
-            graph.addEdge("Mike", "NOT_EXISTED_NODE");
-          }).toThrowError();
-        });
-      });
-
-      if (graphType === EnumGraphType.Undirected) {
-        describe("should correct add edge between two existed vertices", () => {
-          const graph: IGraph<string> = new UndirectedGraph();
-          graph.addVertex("Mike").addVertex("Bob").addEdge("Mike", "Bob");
-
-          it("should add second node to first node neighbors", () => {
-            expect(graph.getVertexNeighbors("Mike")).toContain("Bob");
-          });
-          it("should add first node to second node neighbors", () => {
-            expect(graph.getVertexNeighbors("Bob")).toContain("Mike");
-          });
-        });
-
-        describe("should override an existed edge and its weight", () => {
-          const graph: IGraph<string> = new UndirectedGraph();
-          graph
-            .addVertex("Mike")
-            .addVertex("Bob")
-            .addEdge("Mike", "Bob", 5)
-            .addEdge("Mike", "Bob", 10);
-
-          describe("should not multiple edges", () => {
-            it("should not add vertex to first edge", () => {
-              expect(graph.getVertexNeighbors("Mike")).toEqual(["Bob"]);
-            });
-            it("should not add vertex to second edge", () => {
-              expect(graph.getVertexNeighbors("Bob")).toEqual(["Mike"]);
-            });
-          });
-
-          it("should override edge weight", () => {
-            expect(graph.getEdgeWeight("Mike", "Bob")).toBe(10);
-          });
-        });
-      }
-
-      if (graphType === EnumGraphType.Directed) {
-        describe("should correct add edge between two existed vertices", () => {
-          const graph: IGraph<string> = new DirectedGraph();
-          graph.addVertex("Mike").addVertex("Bob").addEdge("Mike", "Bob");
-
-          it("should add second node to first node neighbors", () => {
-            expect(graph.getVertexNeighbors("Mike")).toContain("Bob");
-          });
-          it("should not add first node to second node neighbors", () => {
-            expect(graph.getVertexNeighbors("Bob")).not.toContain("Mike");
-          });
-        });
-
-        describe("should override an existed edge and its weight", () => {
-          const graph: IGraph<string> = new DirectedGraph();
-          graph
-            .addVertex("Mike")
-            .addVertex("Bob")
-            .addEdge("Mike", "Bob", 5)
-            .addEdge("Bob", "Mike", 15)
-            .addEdge("Mike", "Bob", 10);
-
-          describe("should not multiple edges", () => {
-            it("should not add vertex to first edge", () => {
-              expect(graph.getVertexNeighbors("Mike")).toEqual(["Bob"]);
-            });
-            it("should not add vertex to second edge", () => {
-              expect(graph.getVertexNeighbors("Bob")).toEqual(["Mike"]);
-            });
-          });
-
-          it("should override edge weight", () => {
-            expect(graph.getEdgeWeight("Mike", "Bob")).toBe(10);
-          });
-
-          it("should not override back edge weight", () => {
-            expect(graph.getEdgeWeight("Bob", "Mike")).toBe(15);
-          });
-        });
-      }
-    });
-
-    describe("method removeVertex", () => {
-      it("should throw when try to delete not existed vertex", () => {
-        const graph: IGraph<string> = createGraph(graphType);
-
-        expect(() => {
-          graph.removeVertex("NOT_EXISTED_VERTEX");
-        }).toThrowError();
-      });
-
-      if (graphType === EnumGraphType.Undirected) {
-        describe("should cascade remove", () => {
-          const graph: IGraph<string> = new UndirectedGraph();
-
-          graph
-            .addVertex("Mike")
-            .addVertex("Bob")
-            .addVertex("John")
-            .addVertex("Lisa")
-            .addEdge("Mike", "Bob")
-            .addEdge("Mike", "Lisa")
-            .addEdge("John", "Lisa")
-            .addEdge("Bob", "John");
-
-          graph.removeVertex("Bob");
-
-          it("should remove edges", () => {
-            const hasEdge = graph.hasEdge("Mike", "Bob");
-
-            expect(hasEdge).toBe(false);
-          });
-          it("should remove related vertexes neighbors", () => {
-            const mikeNeighbors = graph.getVertexNeighbors("Mike");
-            const lisaNeighbors = graph.getVertexNeighbors("Lisa");
-            const johnNeighbors = graph.getVertexNeighbors("John");
-
-            expect(mikeNeighbors).toEqual(["Lisa"]);
-            expect(lisaNeighbors).toEqual(["Mike", "John"]);
-            expect(johnNeighbors).toEqual(["Lisa"]);
-          });
-        });
-      }
-
-      if (graphType === EnumGraphType.Directed) {
-        describe("should cascade remove", () => {
-          const graph: IGraph<string> = new DirectedGraph();
-
-          graph
-            .addVertex("Mike")
-            .addVertex("Bob")
-            .addVertex("John")
-            .addVertex("Lisa")
-            .addEdge("Mike", "Bob")
-            .addEdge("Mike", "Lisa")
-            .addEdge("John", "Lisa")
-            .addEdge("Bob", "John");
-
-          graph.removeVertex("Bob");
-
-          it("should remove edges", () => {
-            const hasEdge = graph.hasEdge("Mike", "Bob");
-            expect(hasEdge).toBe(false);
-          });
-
-          it("should remove related vertices neighbors", () => {
-            const mikeNeighbors = graph.getVertexNeighbors("Mike");
-            const lisaNeighbors = graph.getVertexNeighbors("Lisa");
-            const johnNeighbors = graph.getVertexNeighbors("John");
-
-            expect(mikeNeighbors).toEqual(["Lisa"]);
-            expect(lisaNeighbors).toEqual([]);
-            expect(johnNeighbors).toEqual(["Lisa"]);
-          });
-        });
-      }
-    });
-
-    describe("method removeEdge", () => {
-      it("should throw when try to delete not existed edge", () => {
-        const graph: IGraph<string> = createGraph(graphType);
-
-        expect(() => {
-          graph.removeEdge("NOT_EXISTED_VERTEX", "NOT_EXISTED_VERTEX");
-        }).toThrowError();
-      });
-
-      if (graphType === EnumGraphType.Undirected) {
-        describe("should delete correct", () => {
-          const graph: IGraph<string> = new UndirectedGraph();
-
-          graph
-            .addVertex("Mike")
-            .addVertex("Bob")
-            .addVertex("Lisa")
-            .addEdge("Mike", "Bob")
-            .addEdge("Bob", "Lisa")
-            .addEdge("Mike", "Lisa");
-
-          graph.removeEdge("Mike", "Lisa");
-
-          it("should delete correct", () => {
-            expect(graph.hasEdge("Mike", "Lisa")).toBe(false);
-          });
-        });
-      }
-
-      if (graphType === EnumGraphType.Directed) {
-        describe("should delete correct", () => {
-          const graph: IGraph<string> = new DirectedGraph();
-
-          graph
-            .addVertex("Mike")
-            .addVertex("Bob")
-            .addVertex("Lisa")
-            .addEdge("Mike", "Bob")
-            .addEdge("Bob", "Lisa")
-            .addEdge("Mike", "Lisa")
-            .addEdge("Lisa", "Mike");
-
-          graph.removeEdge("Mike", "Lisa");
-
-          it("should delete edge from-to", () => {
-            expect(graph.hasEdge("Mike", "Lisa")).toBe(false);
-          });
-
-          it("should not delete edge to-from", () => {
-            expect(graph.hasEdge("Lisa", "Mike")).toBe(true);
-          });
-        });
-      }
-    });
-
-    describe("method getVertexNeighbors", () => {
-      it("should throw when vertex does not exist", () => {
-        const graph: IGraph<number> = createGraph(graphType);
-        graph.addVertex(1).addVertex(2).addEdge(1, 2);
-
-        expect(() => {
-          graph.getVertexNeighbors(0);
-        }).toThrowError();
-      });
-
-      if (graphType === EnumGraphType.Undirected) {
-        it("should return correct neighbors", () => {
-          const graph: IGraph<number> = new UndirectedGraph();
-          graph
-            .addVertex(1)
-            .addVertex(2)
-            .addVertex(3)
-            .addEdge(1, 2)
-            .addEdge(2, 3);
-
-          expect(graph.getVertexNeighbors(2)).toEqual([1, 3]);
-        });
-      }
-
-      if (graphType === EnumGraphType.Directed) {
-        it("should return correct neighbors", () => {
-          const graph: IGraph<number> = new DirectedGraph();
-          graph
-            .addVertex(1)
-            .addVertex(2)
-            .addVertex(3)
-            .addEdge(1, 2)
-            .addEdge(2, 3);
-
-          expect(graph.getVertexNeighbors(2)).toEqual([3]);
-        });
-      }
-    });
-  }
-);

package/test/unit/data-structures/graph/graph.transpose.test.ts

@@ -1,52 +0,0 @@
-import { createGraph } from "../../../../src/helpers/createGraph";
-import { EnumGraphType } from "../../../../src/types/EnumGraphType";
-import { transposeDirectedGraph } from "../../../../src/data-structures/Graph/transposing/transposeDirectedGraph";
-
-describe("Directed graph transpose", () => {
-  const sourceGraph = createGraph<string>(EnumGraphType.Directed);
-
-  /**
-   * Source matrix
-   *
-   * *  V1 V2 V3 V4
-   * V1  0  1  0  1
-   * V2  0  0  0  0
-   * V3  0  0  0  1
-   * V4  0  0  0  0
-   */
-  sourceGraph
-    .addVertex("Vertex_1")
-    .addVertex("Vertex_2")
-    .addVertex("Vertex_3")
-    .addVertex("Vertex_4")
-    .addEdge("Vertex_1", "Vertex_2")
-    .addEdge("Vertex_1", "Vertex_4")
-    .addEdge("Vertex_3", "Vertex_4");
-
-  /**
-   * Transposed matrix
-   *
-   * *  V1 V2 V3 V4
-   * V1  0  0  0  0
-   * V2  1  0  0  0
-   * V3  0  0  0  0
-   * V4  1  0  1  0
-   */
-  const transposedGraph = transposeDirectedGraph(sourceGraph);
-
-  it("should have the same vertices as source graph", () => {
-    expect(transposedGraph.vertices()).toEqual(sourceGraph.vertices());
-  });
-
-  it("should have all reverted edges", () => {
-    expect(transposedGraph.hasEdge("Vertex_2", "Vertex_1")).toBe(true);
-    expect(transposedGraph.hasEdge("Vertex_4", "Vertex_1")).toBe(true);
-    expect(transposedGraph.hasEdge("Vertex_4", "Vertex_3")).toBe(true);
-  });
-
-  it("should not have edges from source graph", () => {
-    expect(transposedGraph.hasEdge("Vertex_1", "Vertex_2")).toBe(false);
-    expect(transposedGraph.hasEdge("Vertex_1", "Vertex_4")).toBe(false);
-    expect(transposedGraph.hasEdge("Vertex_3", "Vertex_4")).toBe(false);
-  });
-});