@raikuxq/alg-ds 1.0.2 → 1.1.2

package/test/unit/data-structures/binary-tree/binary-search-tree.test.ts

@@ -1,230 +0,0 @@
-import { EnumBinarySearchTreeType } from "../../../../src/types/EnumBinarySearchTreeType";
-import { createBinaryTree } from "../../../../src/helpers/createBinaryTree";
-import { EnumTreeTraversalType } from "../../../../src/types/EnumTreeTraversalType";
-
-describe.each([
-  EnumBinarySearchTreeType.BST,
-  EnumBinarySearchTreeType.RANDOMIZED_BST,
-])("%s", (treeType: EnumBinarySearchTreeType) => {
-  describe("constructor", () => {
-    it("should create an empty instance", () => {
-      const tree = createBinaryTree(treeType);
-
-      expect(tree.length()).toBe(0);
-    });
-  });
-
-  describe("method insert", function () {
-    it("should have added elements to be in order", () => {
-      const tree = createBinaryTree(treeType);
-      tree.insert(5);
-      tree.insert(15);
-      tree.insert(10);
-      tree.insert(0);
-      tree.insert(20);
-
-      expect(tree.traverse(EnumTreeTraversalType.InOrder)).toEqual([
-        0,
-        5,
-        10,
-        15,
-        20,
-      ]);
-    });
-  });
-
-  describe("method length", function () {
-    describe("when tree is non empty", () => {
-      describe("after adding", () => {
-        it("should return updated length value", () => {
-          const tree = createBinaryTree(treeType);
-          tree.insert(5);
-          tree.insert(15);
-          tree.insert(10);
-
-          expect(tree.length()).toBe(3);
-        });
-      });
-
-      describe("after deleting", () => {
-        it("should return updated length value", () => {
-          const tree = createBinaryTree(treeType);
-          tree.insert(5);
-          tree.insert(15);
-          tree.insert(10);
-          tree.delete(5);
-
-          expect(tree.length()).toBe(2);
-        });
-      });
-    });
-
-    describe("when tree is empty", () => {
-      it("should return zero value", () => {
-        const tree = createBinaryTree(treeType);
-
-        expect(tree.length()).toBe(0);
-      });
-    });
-  });
-
-  describe("method height", function () {
-    describe("when tree is non empty", () => {
-      describe("after adding", () => {
-        const tree = createBinaryTree(treeType);
-        const length = 300;
-        const arraySrc = Array.from(Array(length).keys());
-        const arrayShuffled = arraySrc
-          .map((item) => item)
-          .sort(() => Math.random() - 0.5);
-        arrayShuffled.forEach((num, index) => {
-          tree.insert(num);
-        });
-        const height = tree.height();
-
-        it("should be equal or greater than log(length)", () => {
-          const expected = Math.ceil(Math.log2(length));
-          expect(height).toBeGreaterThanOrEqual(expected);
-        });
-        it("should be equal or smaller than length", () => {
-          expect(height).toBeLessThanOrEqual(tree.length());
-        });
-      });
-    });
-
-    describe("when tree is empty", () => {
-      const tree = createBinaryTree(treeType);
-
-      it("should return zero value", () => {
-        expect(tree.height()).toBe(0);
-      });
-    });
-  });
-
-  describe("method has", function () {
-    const tree = createBinaryTree(treeType);
-    tree.insert(5);
-
-    it("should return true when value exists", () => {
-      expect(tree.has(5)).toBe(true);
-    });
-
-    it("should return false when value does not exist", () => {
-      expect(tree.has(10)).toBe(false);
-    });
-  });
-
-  describe("method delete", function () {
-    const tree = createBinaryTree(treeType);
-    tree.insert(5);
-    tree.insert(12);
-    tree.insert(7);
-    tree.insert(20);
-
-    tree.delete(12);
-
-    it("should delete element from the tree", () => {
-      expect(tree.has(12)).toBe(false);
-    });
-
-    it("should restructure the tree correctly", () => {
-      expect(tree.traverse(EnumTreeTraversalType.InOrder)).toEqual([5, 7, 20]);
-    });
-  });
-
-  describe("method max", function () {
-    const tree = createBinaryTree(treeType);
-    tree.insert(5);
-    tree.insert(12);
-    tree.insert(7);
-    tree.insert(20);
-
-    it("should be in order", () => {
-      expect(tree.max()).toBe(20);
-    });
-  });
-
-  describe("method min", function () {
-    const tree = createBinaryTree(treeType);
-    tree.insert(5);
-    tree.insert(12);
-    tree.insert(7);
-    tree.insert(20);
-    tree.insert(2);
-
-    it("should be in order", () => {
-      expect(tree.min()).toBe(2);
-    });
-  });
-
-  if (treeType === EnumBinarySearchTreeType.BST) {
-    describe("method subtree", function () {
-      const bst = createBinaryTree(treeType);
-      bst.insert(22);
-      bst.insert(4);
-      bst.insert(16);
-      bst.insert(19);
-      bst.insert(15);
-      bst.insert(8);
-      bst.insert(23);
-      const subtree = bst.subtree(16);
-
-      it("should correctly create subtree", () => {
-        expect(subtree.traverse(EnumTreeTraversalType.InOrder)).toEqual([
-          8,
-          15,
-          16,
-          19,
-        ]);
-      });
-    });
-
-    describe("method traverse", function () {
-      const bst = createBinaryTree(treeType);
-
-      bst.insert(22);
-      bst.insert(4);
-      bst.insert(16);
-      bst.insert(19);
-      bst.insert(15);
-      bst.insert(8);
-      bst.insert(23);
-
-      it("should correctly convert in-order type", () => {
-        expect(bst.traverse(EnumTreeTraversalType.InOrder)).toEqual([
-          4,
-          8,
-          15,
-          16,
-          19,
-          22,
-          23,
-        ]);
-      });
-
-      it("should correctly convert pre-order type", () => {
-        expect(bst.traverse(EnumTreeTraversalType.PreOrder)).toEqual([
-          22,
-          4,
-          8,
-          15,
-          16,
-          19,
-          23,
-        ]);
-      });
-
-      it("should correctly convert post-order type", () => {
-        expect(bst.traverse(EnumTreeTraversalType.PostOrder)).toEqual([
-          4,
-          8,
-          15,
-          16,
-          19,
-          23,
-          22,
-        ]);
-      });
-    });
-  }
-});

package/test/unit/data-structures/graph/graph.create-from-matrix.test.ts

@@ -1,106 +0,0 @@
-import { EnumGraphType } from "../../../../src/types/EnumGraphType";
-import { createGraphFromMatrix } from "../../../../src/helpers/createGraphFromMatrix";
-import { ArrayMatrix } from "../../../../src/types/ArrayMatrix";
-import IGraph from "../../../../src/types/IGraph";
-
-describe("in Directed graph", () => {
-  /**
-   * Get graph adjacency matrix N x N
-   *
-   * @example
-   *
-   * Directed graph:
-   * - Bob [Maria]
-   * - Maria [Bob, John]
-   * - John []
-   *
-   * Its matrix:
-   *       |  Bob  | Maria |  John |
-   * Bob   |   0   |   1   |   0   |
-   * Maria |   1   |   0   |   1   |
-   * John  |   0   |   0   |   0   |
-   */
-  describe("created graph", () => {
-    const fieldsList: Array<string> = ["Bob", "Maria", "John"];
-
-    const matrix: ArrayMatrix = [
-      [0, 1, 0],
-      [1, 0, 1],
-      [0, 0, 0],
-    ];
-    const graph: IGraph<string> = createGraphFromMatrix<string>(
-      matrix,
-      fieldsList,
-      EnumGraphType.Directed
-    );
-
-    it("should contain all vertices", () => {
-      expect(graph.vertices()).toEqual(fieldsList);
-    });
-
-    it("should contain all edges", () => {
-      expect(graph.hasEdge("Bob", "Bob")).toBe(false);
-      expect(graph.hasEdge("Bob", "Maria")).toBe(true);
-      expect(graph.hasEdge("Bob", "John")).toBe(false);
-
-      expect(graph.hasEdge("Maria", "Maria")).toBe(false);
-      expect(graph.hasEdge("Maria", "Bob")).toBe(true);
-      expect(graph.hasEdge("Maria", "John")).toBe(true);
-
-      expect(graph.hasEdge("John", "John")).toBe(false);
-      expect(graph.hasEdge("John", "Bob")).toBe(false);
-      expect(graph.hasEdge("John", "Maria")).toBe(false);
-    });
-  });
-});
-
-describe("in Undirected graph", () => {
-  /**
-   * Get graph adjacency matrix N x N
-   *
-   * @example
-   *
-   * Directed graph:
-   * - Bob [Maria]
-   * - Maria [Bob, John]
-   * - John []
-   *
-   * Its matrix:
-   *       |  Bob  | Maria |  John |
-   * Bob   |   0   |   1   |   0   |
-   * Maria |   1   |   0   |   1   |
-   * John  |   0   |   1   |   0   |
-   */
-  describe("created graph", () => {
-    const fieldsList: Array<string> = ["Bob", "Maria", "John"];
-
-    const matrix: ArrayMatrix = [
-      [0, 1, 0],
-      [1, 0, 1],
-      [0, 1, 0],
-    ];
-    const graph: IGraph<string> = createGraphFromMatrix<string>(
-      matrix,
-      fieldsList,
-      EnumGraphType.Undirected
-    );
-
-    it("should contain all vertices", () => {
-      expect(graph.vertices()).toEqual(fieldsList);
-    });
-
-    it("should contain all edges", () => {
-      expect(graph.hasEdge("Bob", "Bob")).toBe(false);
-      expect(graph.hasEdge("Bob", "Maria")).toBe(true);
-      expect(graph.hasEdge("Bob", "John")).toBe(false);
-
-      expect(graph.hasEdge("Maria", "Maria")).toBe(false);
-      expect(graph.hasEdge("Maria", "Bob")).toBe(true);
-      expect(graph.hasEdge("Maria", "John")).toBe(true);
-
-      expect(graph.hasEdge("John", "John")).toBe(false);
-      expect(graph.hasEdge("John", "Bob")).toBe(false);
-      expect(graph.hasEdge("John", "Maria")).toBe(true);
-    });
-  });
-});

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

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

@@ -1,76 +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";
-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

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