@raikuxq/alg-ds 1.0.0

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

@@ -0,0 +1,115 @@
+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 DFSIterationStrategy from "../../../../src/data-structures/Graph/strategy/DFSIterationStrategy";
+
+import { hasPath } from "../../../../src/data-structures/Graph/searching/hasPath";
+import { shortestPath } from "../../../../src/data-structures/Graph/searching/shortestPath";
+import { EnumGraphTraversalType } from "../../../../src/types/EnumGraphTraversalType";
+
+describe("Has 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();
+    });
+  });
+
+  describe.each([EnumGraphTraversalType.BFS, EnumGraphTraversalType.DFS])(
+    "%s",
+    (strategyType: EnumGraphTraversalType) => {
+      let strategy: IGraphIterationStrategy<string>;
+
+      switch (strategyType) {
+        case EnumGraphTraversalType.BFS:
+          strategy = new BFSIterationStrategy();
+          break;
+        case EnumGraphTraversalType.DFS:
+          strategy = new DFSIterationStrategy();
+          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")
+          .addVertex("John")
+          .addEdge("Mike", "Bob")
+          .addEdge("Mike", "Lisa")
+          .addEdge("Lisa", "James")
+          .addEdge("Lisa", "Aaron")
+          .addEdge("James", "Aaron")
+          .addEdge("James", "Anna");
+
+        it("should find element if it has an edge", () => {
+          expect(hasPath(graph, "Mike", "Anna", strategy)).toBe(true);
+        });
+        it("should not find element if it has not an edge", () => {
+          expect(hasPath(graph, "Mike", "John", strategy)).toBe(false);
+        });
+      });
+
+      describe("in directed graph", () => {
+        const graph: AbstractGraph<string> = new DirectedGraph();
+
+        graph
+          .addVertex("Mike")
+          .addVertex("Bob")
+          .addVertex("Lisa")
+          .addVertex("Aaron")
+          .addVertex("James")
+          .addVertex("Anna")
+          .addVertex("John")
+          .addEdge("Mike", "Bob")
+          .addEdge("Mike", "Lisa")
+          .addEdge("Lisa", "James")
+          .addEdge("Lisa", "Aaron")
+          .addEdge("James", "Aaron")
+          .addEdge("James", "Anna");
+
+        it("should find element if it has an edge", () => {
+          expect(hasPath(graph, "Mike", "Anna", strategy)).toBe(true);
+        });
+        it("should not find element if it has not an edge", () => {
+          expect(hasPath(graph, "Mike", "John", strategy)).toBe(false);
+        });
+        it("should not find element if and edge has wrong direction", () => {
+          expect(hasPath(graph, "Lisa", "Mike", strategy)).toBe(false);
+        });
+      });
+    }
+  );
+});

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

@@ -0,0 +1,76 @@
+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";
+import { presenterAdjacencyLists } from "../../../../src/data-structures/Graph/presenter/presenterAdjacencyLists";
+
+describe.each([EnumGraphType.Directed, EnumGraphType.Undirected])(
+  "%s graph",
+  (graphType: EnumGraphType) => {
+    describe("in empty graph", () => {
+      const graph: IGraph<number> = createGraph(graphType);
+
+      it("should return empty list", () => {
+        const map = presenterAdjacencyLists(graph);
+        const emptyMap = new Map<number, number>();
+        expect(map).toEqual(emptyMap);
+      });
+    });
+
+    if (graphType === EnumGraphType.Undirected) {
+      describe("in non-empty graph", () => {
+        const graph: IGraph<number> = new UndirectedGraph();
+        graph
+          .addVertex(1)
+          .addVertex(2)
+          .addVertex(3)
+          .addVertex(4)
+          .addEdge(1, 2)
+          .addEdge(1, 3)
+          .addEdge(3, 4);
+
+        it("should return correct list", () => {
+          const list = presenterAdjacencyLists(graph);
+          const expectedList = new Map<number, Array<number>>();
+
+          // eslint-disable-next-line
+          expectedList
+              .set(1, [2, 3])
+              .set(2, [1])
+              .set(3, [1, 4])
+              .set(4, [3]);
+
+          expect(list).toEqual(expectedList);
+        });
+      });
+    }
+    if (graphType === EnumGraphType.Directed) {
+      describe("in non-empty graph", () => {
+        const graph: IGraph<number> = new DirectedGraph();
+        graph
+          .addVertex(1)
+          .addVertex(2)
+          .addVertex(3)
+          .addVertex(4)
+          .addEdge(1, 2)
+          .addEdge(1, 3)
+          .addEdge(3, 4);
+
+        it("should return correct list", () => {
+          const list = presenterAdjacencyLists(graph);
+          const expectedList = new Map<number, Array<number>>();
+
+          // eslint-disable-next-line
+          expectedList
+              .set(1, [2, 3])
+              .set(2, [])
+              .set(3, [4])
+              .set(4, []);
+
+          expect(list).toEqual(expectedList);
+        });
+      });
+    }
+  }
+);

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

@@ -0,0 +1,73 @@
+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";
+import { presenterAdjacencyMatrix } from "../../../../src/data-structures/Graph/presenter/presenterAdjacencyMatrix";
+
+describe("Graph Presenter Matrix", () => {
+  describe.each([EnumGraphType.Directed, EnumGraphType.Undirected])(
+    "%s graph",
+    (graphType: EnumGraphType) => {
+      describe("in empty graph", () => {
+        const graph: IGraph<string> = createGraph(graphType);
+
+        it("should return empty list", () => {
+          const matrix = presenterAdjacencyMatrix(graph);
+
+          expect(matrix).toEqual([]);
+        });
+      });
+
+      if (graphType === EnumGraphType.Undirected) {
+        describe("in non-empty graph", () => {
+          const graph: IGraph<number> = new UndirectedGraph();
+          graph
+            .addVertex(1)
+            .addVertex(2)
+            .addVertex(3)
+            .addVertex(4)
+            .addEdge(1, 2)
+            .addEdge(1, 3)
+            .addEdge(3, 4);
+
+          it("should return correct matrix", () => {
+            const matrix = presenterAdjacencyMatrix(graph);
+
+            expect(matrix).toEqual([
+              [0, 1, 1, 0],
+              [1, 0, 0, 0],
+              [1, 0, 0, 1],
+              [0, 0, 1, 0],
+            ]);
+          });
+        });
+      }
+
+      if (graphType === EnumGraphType.Directed) {
+        describe("in non-empty graph", () => {
+          const graph: IGraph<number> = new DirectedGraph();
+          graph
+            .addVertex(1)
+            .addVertex(2)
+            .addVertex(3)
+            .addVertex(4)
+            .addEdge(1, 2)
+            .addEdge(1, 3)
+            .addEdge(3, 4);
+
+          it("should return correct matrix", () => {
+            const matrix = presenterAdjacencyMatrix(graph);
+
+            expect(matrix).toEqual([
+              [0, 1, 1, 0],
+              [0, 0, 0, 0],
+              [0, 0, 0, 1],
+              [0, 0, 0, 0],
+            ]);
+          });
+        });
+      }
+    }
+  );
+});

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

@@ -0,0 +1,207 @@
+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",
+          ]);
+        });
+      });
+    }
+  );
+});