@raikuxq/alg-ds 1.1.6 → 1.1.7

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/lib/data-structures/Graph/presenter/presenterAdjacencyMatrix.d.ts

@@ -0,0 +1,32 @@
+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,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasPath = void 0;
+var IsNotFoundException_1 = require("../../../exceptions/IsNotFoundException");
+/**
+ * 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 IsNotFoundException_1.default("Start vertex was not found");
+    }
+    if (!graph.hasVertex(to)) {
+        throw new IsNotFoundException_1.default("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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFzUGF0aC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kYXRhLXN0cnVjdHVyZXMvR3JhcGgvc2VhcmNoaW5nL2hhc1BhdGgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBR0EsK0VBQTBFO0FBRTFFOzs7OztHQUtHO0FBQ1UsUUFBQSxPQUFPLEdBQUcsVUFDckIsS0FBZ0IsRUFDaEIsSUFBTyxFQUNQLEVBQUssRUFDTCxRQUFvQztJQUVwQyxjQUFjO0lBQ2QsSUFBSSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEVBQUU7UUFDMUIsTUFBTSxJQUFJLDZCQUFtQixDQUFDLDRCQUE0QixDQUFDLENBQUM7S0FDN0Q7SUFDRCxJQUFJLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsRUFBRTtRQUN4QixNQUFNLElBQUksNkJBQW1CLENBQUMsMEJBQTBCLENBQUMsQ0FBQztLQUMzRDtJQUVELElBQU0sUUFBUSxHQUFzQixRQUFRLENBQUMsY0FBYyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ25FLFFBQVEsQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLENBQUM7SUFFNUIseUJBQXlCO0lBQ3pCLE9BQU8sUUFBUSxDQUFDLE9BQU8sRUFBRSxFQUFFO1FBQ3pCLElBQU0sSUFBSSxHQUFHLFFBQVEsQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUU3QixJQUFJLElBQUksS0FBSyxFQUFFLEVBQUU7WUFDZixPQUFPLElBQUksQ0FBQztTQUNiO0tBQ0Y7SUFFRCxPQUFPLEtBQUssQ0FBQztBQUNmLENBQUMsQ0FBQyJ9

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,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shortestPath = void 0;
+var IsNotFoundException_1 = require("../../../exceptions/IsNotFoundException");
+/**
+ * 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 IsNotFoundException_1.default("Start vertex was not found");
+    }
+    if (!graph.hasVertex(to)) {
+        throw new IsNotFoundException_1.default("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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hvcnRlc3RQYXRoLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RhdGEtc3RydWN0dXJlcy9HcmFwaC9zZWFyY2hpbmcvc2hvcnRlc3RQYXRoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUdBLCtFQUEwRTtBQUUxRTs7Ozs7R0FLRztBQUNVLFFBQUEsWUFBWSxHQUFHLFVBQzFCLEtBQWdCLEVBQ2hCLElBQU8sRUFDUCxFQUFLLEVBQ0wsUUFBb0M7SUFFcEMsY0FBYztJQUNkLElBQUksQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxFQUFFO1FBQzFCLE1BQU0sSUFBSSw2QkFBbUIsQ0FBQyw0QkFBNEIsQ0FBQyxDQUFDO0tBQzdEO0lBQ0QsSUFBSSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLEVBQUU7UUFDeEIsTUFBTSxJQUFJLDZCQUFtQixDQUFDLDBCQUEwQixDQUFDLENBQUM7S0FDM0Q7SUFFRCxJQUFNLFFBQVEsR0FBc0IsUUFBUSxDQUFDLGNBQWMsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNuRSxRQUFRLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBRTVCLHlCQUF5QjtJQUN6QixPQUFPLFFBQVEsQ0FBQyxPQUFPLEVBQUUsRUFBRTtRQUN6QixJQUFNLElBQUksR0FBRyxRQUFRLENBQUMsSUFBSSxFQUFFLENBQUM7UUFFN0IsSUFBSSxJQUFJLEtBQUssRUFBRSxFQUFFO1lBQ2YsTUFBTTtTQUNQO0tBQ0Y7SUFFRCxPQUFPLFFBQVEsQ0FBQyxPQUFPLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxDQUFDO0FBQ3BDLENBQUMsQ0FBQyJ9

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,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var HashTableNode_1 = require("./HashTableNode");
+var IllegalCapacityException_1 = require("../../exceptions/IllegalCapacityException");
+var IsNotFoundException_1 = require("../../exceptions/IsNotFoundException");
+/**
+ * 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 IllegalCapacityException_1.default("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 IsNotFoundException_1.default("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 IsNotFoundException_1.default("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=