@raikuxq/alg-ds 1.1.2 → 1.1.5

package/lib/data-structures/Graph/presenter/presenterAdjacencyLists.d.ts

@@ -0,0 +1,19 @@
+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 declare const presenterAdjacencyLists: <T>(graph: IGraph<T>) => Map<T, T[]>;

package/lib/data-structures/Graph/presenter/presenterAdjacencyLists.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.presenterAdjacencyLists = void 0;
+/**
+ * Get graph adjacency list
+ *
+ * @example
+ *
+ * Directed graph:
+ * - Bob [Maria]
+ * - Maria [Bob, John]
+ * - John []
+ *
+ * @example
+ *
+ * Undirected graph:
+ * - Bob [Maria]
+ * - Maria [Bob, John]
+ * - John [Maria]
+ **/
+exports.presenterAdjacencyLists = function (graph) {
+    return graph.vertices().reduce(function (map, vertex) {
+        var neighbors = graph.getVertexNeighbors(vertex);
+        map.set(vertex, neighbors);
+        return map;
+    }, new Map());
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJlc2VudGVyQWRqYWNlbmN5TGlzdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZGF0YS1zdHJ1Y3R1cmVzL0dyYXBoL3ByZXNlbnRlci9wcmVzZW50ZXJBZGphY2VuY3lMaXN0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFQTs7Ozs7Ozs7Ozs7Ozs7OztJQWdCSTtBQUNTLFFBQUEsdUJBQXVCLEdBQUcsVUFDckMsS0FBZ0I7SUFFaEIsT0FBTyxLQUFLLENBQUMsUUFBUSxFQUFFLENBQUMsTUFBTSxDQUFDLFVBQUMsR0FBcUIsRUFBRSxNQUFTO1FBQzlELElBQU0sU0FBUyxHQUFHLEtBQUssQ0FBQyxrQkFBa0IsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUNuRCxHQUFHLENBQUMsR0FBRyxDQUFDLE1BQU0sRUFBRSxTQUFTLENBQUMsQ0FBQztRQUUzQixPQUFPLEdBQUcsQ0FBQztJQUNiLENBQUMsRUFBRSxJQUFJLEdBQUcsRUFBRSxDQUFDLENBQUM7QUFDaEIsQ0FBQyxDQUFDIn0=

package/{src/data-structures/Graph/presenter/presenterAdjacencyMatrix.ts → lib/data-structures/Graph/presenter/presenterAdjacencyMatrix.d.ts}

@@ -1,51 +1,32 @@
-import IGraph from "../../../types/IGraph";
-import { EDGE_EXISTS_STATE, EDGE_NOT_EXISTS_STATE } from "../../../constants";
-import { ArrayMatrix } from "../../../types/ArrayMatrix";
-
-/**
- * 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   |
- *
- * @example
- *
- * Undirected graph:
- * - Bob [Maria]
- * - Maria [Bob, John]
- * - John [Maria]
- *
- * Its matrix:
- *       |  Bob  | Maria |  John |
- * Bob   |   0   |   1   |   0   |
- * Maria |   1   |   0   |   1   |
- * John  |   0   |   1   |   0   |
- */
-export const presenterAdjacencyMatrix = <T>(graph: IGraph<T>): ArrayMatrix => {
-  const vertices = graph.vertices();
-  const matrix = new Array(graph.verticesCount());
-
-  vertices.forEach((graphVertexRow, rowIndex) => {
-    matrix[rowIndex] = new Array(graph.verticesCount());
-
-    vertices.forEach((graphVertexColumn, columnIndex) => {
-      const isElementLinked = graph.hasEdge(graphVertexRow, graphVertexColumn);
-
-      matrix[rowIndex][columnIndex] = isElementLinked
-        ? EDGE_EXISTS_STATE
-        : EDGE_NOT_EXISTS_STATE;
-    });
-  });
-
-  return matrix;
-};
+import IGraph from "../../../types/IGraph";
+import { ArrayMatrix } from "../../../types/ArrayMatrix";
+/**
+ * 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   |
+ *
+ * @example
+ *
+ * Undirected graph:
+ * - Bob [Maria]
+ * - Maria [Bob, John]
+ * - John [Maria]
+ *
+ * Its matrix:
+ *       |  Bob  | Maria |  John |
+ * Bob   |   0   |   1   |   0   |
+ * Maria |   1   |   0   |   1   |
+ * John  |   0   |   1   |   0   |
+ */
+export declare const presenterAdjacencyMatrix: <T>(graph: IGraph<T>) => ArrayMatrix;

package/lib/data-structures/Graph/presenter/presenterAdjacencyMatrix.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.presenterAdjacencyMatrix = void 0;
+var constants_1 = require("../../../constants");
+/**
+ * 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   |
+ *
+ * @example
+ *
+ * Undirected graph:
+ * - Bob [Maria]
+ * - Maria [Bob, John]
+ * - John [Maria]
+ *
+ * Its matrix:
+ *       |  Bob  | Maria |  John |
+ * Bob   |   0   |   1   |   0   |
+ * Maria |   1   |   0   |   1   |
+ * John  |   0   |   1   |   0   |
+ */
+exports.presenterAdjacencyMatrix = function (graph) {
+    var vertices = graph.vertices();
+    var matrix = new Array(graph.verticesCount());
+    vertices.forEach(function (graphVertexRow, rowIndex) {
+        matrix[rowIndex] = new Array(graph.verticesCount());
+        vertices.forEach(function (graphVertexColumn, columnIndex) {
+            var isElementLinked = graph.hasEdge(graphVertexRow, graphVertexColumn);
+            matrix[rowIndex][columnIndex] = isElementLinked
+                ? constants_1.EDGE_EXISTS_STATE
+                : constants_1.EDGE_NOT_EXISTS_STATE;
+        });
+    });
+    return matrix;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJlc2VudGVyQWRqYWNlbmN5TWF0cml4LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RhdGEtc3RydWN0dXJlcy9HcmFwaC9wcmVzZW50ZXIvcHJlc2VudGVyQWRqYWNlbmN5TWF0cml4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNBLGdEQUE4RTtBQUc5RTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQTRCRztBQUNVLFFBQUEsd0JBQXdCLEdBQUcsVUFBSSxLQUFnQjtJQUMxRCxJQUFNLFFBQVEsR0FBRyxLQUFLLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDbEMsSUFBTSxNQUFNLEdBQUcsSUFBSSxLQUFLLENBQUMsS0FBSyxDQUFDLGFBQWEsRUFBRSxDQUFDLENBQUM7SUFFaEQsUUFBUSxDQUFDLE9BQU8sQ0FBQyxVQUFDLGNBQWMsRUFBRSxRQUFRO1FBQ3hDLE1BQU0sQ0FBQyxRQUFRLENBQUMsR0FBRyxJQUFJLEtBQUssQ0FBQyxLQUFLLENBQUMsYUFBYSxFQUFFLENBQUMsQ0FBQztRQUVwRCxRQUFRLENBQUMsT0FBTyxDQUFDLFVBQUMsaUJBQWlCLEVBQUUsV0FBVztZQUM5QyxJQUFNLGVBQWUsR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFDLGNBQWMsRUFBRSxpQkFBaUIsQ0FBQyxDQUFDO1lBRXpFLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyxXQUFXLENBQUMsR0FBRyxlQUFlO2dCQUM3QyxDQUFDLENBQUMsNkJBQWlCO2dCQUNuQixDQUFDLENBQUMsaUNBQXFCLENBQUM7UUFDNUIsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDLENBQUMsQ0FBQztJQUVILE9BQU8sTUFBTSxDQUFDO0FBQ2hCLENBQUMsQ0FBQyJ9

package/lib/data-structures/Graph/searching/hasPath.d.ts

@@ -0,0 +1,9 @@
+import IGraph from "../../../types/IGraph";
+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 declare const hasPath: <T>(graph: IGraph<T>, from: T, to: T, strategy: IGraphIterationStrategy<T>) => boolean;

package/lib/data-structures/Graph/searching/hasPath.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasPath = void 0;
+/**
+ * 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
+ */
+exports.hasPath = function (graph, from, to, strategy) {
+    /* 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");
+    }
+    var iterator = strategy.createIterator(graph);
+    iterator.initIterator(from);
+    /* Find target element */
+    while (iterator.hasNext()) {
+        var next = iterator.next();
+        if (next === to) {
+            return true;
+        }
+    }
+    return false;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFzUGF0aC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kYXRhLXN0cnVjdHVyZXMvR3JhcGgvc2VhcmNoaW5nL2hhc1BhdGgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBSUE7Ozs7O0dBS0c7QUFDVSxRQUFBLE9BQU8sR0FBRyxVQUNyQixLQUFnQixFQUNoQixJQUFPLEVBQ1AsRUFBSyxFQUNMLFFBQW9DO0lBRXBDLGNBQWM7SUFDZCxJQUFJLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsRUFBRTtRQUMxQixNQUFNLElBQUksS0FBSyxDQUFDLDRCQUE0QixDQUFDLENBQUM7S0FDL0M7SUFDRCxJQUFJLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsRUFBRTtRQUN4QixNQUFNLElBQUksS0FBSyxDQUFDLDBCQUEwQixDQUFDLENBQUM7S0FDN0M7SUFFRCxJQUFNLFFBQVEsR0FBc0IsUUFBUSxDQUFDLGNBQWMsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNuRSxRQUFRLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBRTVCLHlCQUF5QjtJQUN6QixPQUFPLFFBQVEsQ0FBQyxPQUFPLEVBQUUsRUFBRTtRQUN6QixJQUFNLElBQUksR0FBRyxRQUFRLENBQUMsSUFBSSxFQUFFLENBQUM7UUFFN0IsSUFBSSxJQUFJLEtBQUssRUFBRSxFQUFFO1lBQ2YsT0FBTyxJQUFJLENBQUM7U0FDYjtLQUNGO0lBRUQsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDLENBQUMifQ==

package/lib/data-structures/Graph/searching/shortestPath.d.ts

@@ -0,0 +1,9 @@
+import IGraph from "../../../types/IGraph";
+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 declare const shortestPath: <T>(graph: IGraph<T>, from: T, to: T, strategy: IGraphIterationStrategy<T>) => T[];

package/lib/data-structures/Graph/searching/shortestPath.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shortestPath = void 0;
+/**
+ * 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
+ */
+exports.shortestPath = function (graph, from, to, strategy) {
+    /* 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");
+    }
+    var iterator = strategy.createIterator(graph);
+    iterator.initIterator(from);
+    /* Find target element */
+    while (iterator.hasNext()) {
+        var next = iterator.next();
+        if (next === to) {
+            break;
+        }
+    }
+    return iterator.getPath(from, to);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hvcnRlc3RQYXRoLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RhdGEtc3RydWN0dXJlcy9HcmFwaC9zZWFyY2hpbmcvc2hvcnRlc3RQYXRoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUlBOzs7OztHQUtHO0FBQ1UsUUFBQSxZQUFZLEdBQUcsVUFDMUIsS0FBZ0IsRUFDaEIsSUFBTyxFQUNQLEVBQUssRUFDTCxRQUFvQztJQUVwQyxjQUFjO0lBQ2QsSUFBSSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEVBQUU7UUFDMUIsTUFBTSxJQUFJLEtBQUssQ0FBQyw0QkFBNEIsQ0FBQyxDQUFDO0tBQy9DO0lBQ0QsSUFBSSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLEVBQUU7UUFDeEIsTUFBTSxJQUFJLEtBQUssQ0FBQywwQkFBMEIsQ0FBQyxDQUFDO0tBQzdDO0lBRUQsSUFBTSxRQUFRLEdBQXNCLFFBQVEsQ0FBQyxjQUFjLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDbkUsUUFBUSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUU1Qix5QkFBeUI7SUFDekIsT0FBTyxRQUFRLENBQUMsT0FBTyxFQUFFLEVBQUU7UUFDekIsSUFBTSxJQUFJLEdBQUcsUUFBUSxDQUFDLElBQUksRUFBRSxDQUFDO1FBRTdCLElBQUksSUFBSSxLQUFLLEVBQUUsRUFBRTtZQUNmLE1BQU07U0FDUDtLQUNGO0lBRUQsT0FBTyxRQUFRLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsQ0FBQztBQUNwQyxDQUFDLENBQUMifQ==

package/lib/data-structures/Graph/strategy/BFSIterationStrategy.d.ts

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

package/lib/data-structures/Graph/strategy/BFSIterationStrategy.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var GraphIteratorBFS_1 = require("../iterator/GraphIteratorBFS");
+var BFSIterationStrategy = /** @class */ (function () {
+    function BFSIterationStrategy() {
+    }
+    BFSIterationStrategy.prototype.createIterator = function (graph) {
+        return new GraphIteratorBFS_1.default(graph);
+    };
+    return BFSIterationStrategy;
+}());
+exports.default = BFSIterationStrategy;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQkZTSXRlcmF0aW9uU3RyYXRlZ3kuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZGF0YS1zdHJ1Y3R1cmVzL0dyYXBoL3N0cmF0ZWd5L0JGU0l0ZXJhdGlvblN0cmF0ZWd5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBR0EsaUVBQTREO0FBRTVEO0lBQUE7SUFLQSxDQUFDO0lBSFEsNkNBQWMsR0FBckIsVUFBc0IsS0FBZ0I7UUFDcEMsT0FBTyxJQUFJLDBCQUFnQixDQUFJLEtBQUssQ0FBQyxDQUFDO0lBQ3hDLENBQUM7SUFDSCwyQkFBQztBQUFELENBQUMsQUFMRCxJQUtDIn0=

package/lib/data-structures/Graph/strategy/DFSIterationStrategy.d.ts

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

package/lib/data-structures/Graph/strategy/DFSIterationStrategy.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var GraphIteratorDFS_1 = require("../iterator/GraphIteratorDFS");
+var DFSIterationStrategy = /** @class */ (function () {
+    function DFSIterationStrategy() {
+    }
+    DFSIterationStrategy.prototype.createIterator = function (graph) {
+        return new GraphIteratorDFS_1.default(graph);
+    };
+    return DFSIterationStrategy;
+}());
+exports.default = DFSIterationStrategy;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiREZTSXRlcmF0aW9uU3RyYXRlZ3kuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZGF0YS1zdHJ1Y3R1cmVzL0dyYXBoL3N0cmF0ZWd5L0RGU0l0ZXJhdGlvblN0cmF0ZWd5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBR0EsaUVBQTREO0FBRTVEO0lBQUE7SUFLQSxDQUFDO0lBSFEsNkNBQWMsR0FBckIsVUFBc0IsS0FBZ0I7UUFDcEMsT0FBTyxJQUFJLDBCQUFnQixDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3JDLENBQUM7SUFDSCwyQkFBQztBQUFELENBQUMsQUFMRCxJQUtDIn0=

package/lib/data-structures/Graph/strategy/DijkstraIterationStrategy.d.ts

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

package/lib/data-structures/Graph/strategy/DijkstraIterationStrategy.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var GraphIteratorDijkstra_1 = require("../iterator/GraphIteratorDijkstra");
+var DijkstraIterationStrategy = /** @class */ (function () {
+    function DijkstraIterationStrategy() {
+    }
+    DijkstraIterationStrategy.prototype.createIterator = function (graph) {
+        return new GraphIteratorDijkstra_1.default(graph);
+    };
+    return DijkstraIterationStrategy;
+}());
+exports.default = DijkstraIterationStrategy;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGlqa3N0cmFJdGVyYXRpb25TdHJhdGVneS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kYXRhLXN0cnVjdHVyZXMvR3JhcGgvc3RyYXRlZ3kvRGlqa3N0cmFJdGVyYXRpb25TdHJhdGVneS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUdBLDJFQUFzRTtBQUV0RTtJQUFBO0lBS0EsQ0FBQztJQUhRLGtEQUFjLEdBQXJCLFVBQXNCLEtBQWdCO1FBQ3BDLE9BQU8sSUFBSSwrQkFBcUIsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUMxQyxDQUFDO0lBQ0gsZ0NBQUM7QUFBRCxDQUFDLEFBTEQsSUFLQyJ9

package/lib/data-structures/Graph/transposing/transposeDirectedGraph.d.ts

@@ -0,0 +1,2 @@
+import IGraph from "../../../types/IGraph";
+export declare const transposeDirectedGraph: <T>(sourceGraph: IGraph<T>) => IGraph<T>;

package/lib/data-structures/Graph/transposing/transposeDirectedGraph.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transposeDirectedGraph = void 0;
+var createGraphFromMatrix_1 = require("../../../helpers/createGraphFromMatrix");
+var EnumGraphType_1 = require("../../../types/EnumGraphType");
+var presenterAdjacencyMatrix_1 = require("../presenter/presenterAdjacencyMatrix");
+var transpose_matrix_1 = require("../../../algorithms/transpose-matrix");
+exports.transposeDirectedGraph = function (sourceGraph) {
+    var verticesList = sourceGraph.vertices();
+    var matrix = presenterAdjacencyMatrix_1.presenterAdjacencyMatrix(sourceGraph);
+    var transposedMatrix = transpose_matrix_1.transposeMatrix(matrix);
+    return createGraphFromMatrix_1.createGraphFromMatrix(transposedMatrix, verticesList, EnumGraphType_1.EnumGraphType.Directed);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNwb3NlRGlyZWN0ZWRHcmFwaC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kYXRhLXN0cnVjdHVyZXMvR3JhcGgvdHJhbnNwb3NpbmcvdHJhbnNwb3NlRGlyZWN0ZWRHcmFwaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSxnRkFBK0U7QUFDL0UsOERBQTZEO0FBQzdELGtGQUFpRjtBQUNqRix5RUFBdUU7QUFFMUQsUUFBQSxzQkFBc0IsR0FBRyxVQUNwQyxXQUFzQjtJQUV0QixJQUFNLFlBQVksR0FBRyxXQUFXLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDNUMsSUFBTSxNQUFNLEdBQUcsbURBQXdCLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDckQsSUFBTSxnQkFBZ0IsR0FBRyxrQ0FBZSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBRWpELE9BQU8sNkNBQXFCLENBQzFCLGdCQUFnQixFQUNoQixZQUFZLEVBQ1osNkJBQWEsQ0FBQyxRQUFRLENBQ3ZCLENBQUM7QUFDSixDQUFDLENBQUMifQ==

package/lib/data-structures/HashTable/HashTable.d.ts

@@ -0,0 +1,73 @@
+import IKeyValueStorage from "../../types/IKeyValueStorage";
+/**
+ * Implementation of open addressing hash table using quadratic probing
+ */
+export default class HashTable<T> implements IKeyValueStorage<T> {
+    /**
+     Constants
+     */
+    private static DEFAULT_MAX_CAPACITY;
+    private static MAX_LOAD_FACTOR;
+    /**
+     * State
+     */
+    private storage;
+    private maxCapacity;
+    private storageCapacity;
+    /**
+     * Given init capacity size will be used
+     * @throws when initial capacity value is not larger than 0
+     */
+    constructor(initialCapacity?: number);
+    /**
+     * Main-hash function
+     */
+    private hashFn;
+    /**
+     * Helper-hash function
+     */
+    private innerHashFn;
+    /**
+     * Max capacity will be increased and storage will be overwritten
+     */
+    private resizeStorage;
+    /**
+     * Will find node instance by its key
+     * @throws when element does not exist
+     */
+    private findNode;
+    /**
+     * Will create new node instance and set in to storage by index
+     */
+    private addNode;
+    /**
+     * Will create new node instance and set in to storage by index
+     */
+    private updateNode;
+    /**
+     * Will insert item to hash table
+     */
+    set(key: string, data: T): void;
+    /**
+     * Will update item property isDeleted to false
+     * @throws when element does not exist
+     */
+    delete(key: string): void;
+    /**
+     * Will find item in hash table
+     * @throws when element does not exist
+     */
+    get(key: string): T;
+    /**
+     * Check if node with given key exists
+     */
+    has(key: string): boolean;
+    /**
+     * Added elements count
+     */
+    length(): number;
+    /**
+     * Will overwrite storage with array of null elements
+     */
+    clear(): void;
+}

package/lib/data-structures/HashTable/HashTable.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var HashTableNode_1 = require("./HashTableNode");
+/**
+ * Implementation of open addressing hash table using quadratic probing
+ */
+var HashTable = /** @class */ (function () {
+    /**
+     * Given init capacity size will be used
+     * @throws when initial capacity value is not larger than 0
+     */
+    function HashTable(initialCapacity) {
+        if (initialCapacity === void 0) { initialCapacity = HashTable.DEFAULT_MAX_CAPACITY; }
+        this.storageCapacity = 0;
+        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
+     */
+    HashTable.prototype.hashFn = function (key, number) {
+        return ((this.innerHashFn(key) + 127 * number + 365 * number * number) %
+            this.maxCapacity);
+    };
+    /**
+     * Helper-hash function
+     */
+    HashTable.prototype.innerHashFn = function (key) {
+        var length = key.length;
+        if (length === 0) {
+            return 0;
+        }
+        var substring = key.substring(0, length - 1);
+        var symbol = key.charCodeAt(length - 1);
+        return (127 * this.innerHashFn(substring) + symbol) % this.maxCapacity;
+    };
+    /**
+     * Max capacity will be increased and storage will be overwritten
+     */
+    HashTable.prototype.resizeStorage = function () {
+        this.maxCapacity *= 2;
+        var newArray = new Array(this.maxCapacity).fill(null);
+        for (var i = 0; i < this.storage.length; i++) {
+            var element = this.storage[i];
+            if (element != null) {
+                for (var j = 0; j < this.maxCapacity; j++) {
+                    var 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
+     */
+    HashTable.prototype.findNode = function (key) {
+        for (var i = 0; i < this.maxCapacity; i++) {
+            var index = this.hashFn(key, i);
+            var node = this.storage[index];
+            if ((node === null || node === void 0 ? void 0 : node.key) === key) {
+                if (node === null || node === void 0 ? void 0 : node.isDeleted) {
+                    break;
+                }
+                return node;
+            }
+        }
+        throw new Error("Element does not exist");
+    };
+    /**
+     * Will create new node instance and set in to storage by index
+     */
+    HashTable.prototype.addNode = function (key, data, index) {
+        this.storage[index] = new HashTableNode_1.default(key, data);
+        this.storageCapacity++;
+        var 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
+     */
+    HashTable.prototype.updateNode = function (data, index) {
+        this.storage[index].data = data;
+        this.storage[index].isDeleted = false;
+    };
+    /**
+     * Will insert item to hash table
+     */
+    HashTable.prototype.set = function (key, data) {
+        for (var i = 0; i < this.maxCapacity; i++) {
+            var index = this.hashFn(key, i);
+            var node = this.storage[index];
+            var shouldAddNode = node === null;
+            if (shouldAddNode) {
+                this.addNode(key, data, index);
+                break;
+            }
+            var shouldUpdateNode = node.key === key;
+            if (shouldUpdateNode) {
+                this.updateNode(data, index);
+                break;
+            }
+        }
+    };
+    /**
+     * Will update item property isDeleted to false
+     * @throws when element does not exist
+     */
+    HashTable.prototype.delete = function (key) {
+        for (var i = 0; i < this.maxCapacity; i++) {
+            var 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
+     */
+    HashTable.prototype.get = function (key) {
+        return this.findNode(key).data;
+    };
+    /**
+     * Check if node with given key exists
+     */
+    HashTable.prototype.has = function (key) {
+        try {
+            return Boolean(this.findNode(key));
+        }
+        catch (e) {
+            return false;
+        }
+    };
+    /**
+     * Added elements count
+     */
+    HashTable.prototype.length = function () {
+        var actualItems = this.storage.filter(function (item) {
+            return item !== null && !item.isDeleted;
+        });
+        return actualItems.length;
+    };
+    /**
+     * Will overwrite storage with array of null elements
+     */
+    HashTable.prototype.clear = function () {
+        this.storage = new Array(HashTable.DEFAULT_MAX_CAPACITY).fill(null);
+    };
+    /**
+     Constants
+     */
+    HashTable.DEFAULT_MAX_CAPACITY = 100;
+    HashTable.MAX_LOAD_FACTOR = 0.5;
+    return HashTable;
+}());
+exports.default = HashTable;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/data-structures/HashTable/HashTableNode.d.ts

@@ -0,0 +1,11 @@
+export default class HashTableNode<T> {
+    private readonly _key;
+    private _data;
+    private _isDeleted;
+    constructor(key: string, data: T);
+    get data(): T;
+    set data(value: T);
+    get key(): string;
+    get isDeleted(): boolean;
+    set isDeleted(value: boolean);
+}

package/lib/data-structures/HashTable/HashTableNode.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var HashTableNode = /** @class */ (function () {
+    function HashTableNode(key, data) {
+        this._key = key;
+        this._data = data;
+        this._isDeleted = false;
+    }
+    Object.defineProperty(HashTableNode.prototype, "data", {
+        get: function () {
+            return this._data;
+        },
+        set: function (value) {
+            this._data = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(HashTableNode.prototype, "key", {
+        get: function () {
+            return this._key;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(HashTableNode.prototype, "isDeleted", {
+        get: function () {
+            return this._isDeleted;
+        },
+        set: function (value) {
+            this._isDeleted = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return HashTableNode;
+}());
+exports.default = HashTableNode;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSGFzaFRhYmxlTm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kYXRhLXN0cnVjdHVyZXMvSGFzaFRhYmxlL0hhc2hUYWJsZU5vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQTtJQUtFLHVCQUFtQixHQUFXLEVBQUUsSUFBTztRQUNyQyxJQUFJLENBQUMsSUFBSSxHQUFHLEdBQUcsQ0FBQztRQUNoQixJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQztRQUNsQixJQUFJLENBQUMsVUFBVSxHQUFHLEtBQUssQ0FBQztJQUMxQixDQUFDO0lBRUQsc0JBQUksK0JBQUk7YUFBUjtZQUNFLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQztRQUNwQixDQUFDO2FBRUQsVUFBUyxLQUFRO1lBQ2YsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7UUFDckIsQ0FBQzs7O09BSkE7SUFNRCxzQkFBSSw4QkFBRzthQUFQO1lBQ0UsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDO1FBQ25CLENBQUM7OztPQUFBO0lBRUQsc0JBQUksb0NBQVM7YUFBYjtZQUNFLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQztRQUN6QixDQUFDO2FBRUQsVUFBYyxLQUFjO1lBQzFCLElBQUksQ0FBQyxVQUFVLEdBQUcsS0FBSyxDQUFDO1FBQzFCLENBQUM7OztPQUpBO0lBS0gsb0JBQUM7QUFBRCxDQUFDLEFBOUJELElBOEJDIn0=