@raikuxq/alg-ds 1.1.2 → 1.1.5

package/lib/data-structures/Graph/UndirectedGraph.js

@@ -0,0 +1,102 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var AbstractGraph_1 = require("./AbstractGraph");
+var GraphEdge_1 = require("./GraphEdge");
+/**
+ * Undirected graph - data structure where edges with same pair of vertices are equal
+ * @example A-B is same as B-A
+ */
+var UndirectedGraph = /** @class */ (function (_super) {
+    __extends(UndirectedGraph, _super);
+    /**
+     * @inheritDoc
+     */
+    function UndirectedGraph() {
+        return _super.call(this) || this;
+    }
+    /**
+     * @inheritDoc
+     */
+    UndirectedGraph.prototype.getEdgeByValue = function (from, to) {
+        var edge = this._edges.find(function (edge) {
+            return (edge.fromVertex === from && edge.toVertex === to) ||
+                (edge.fromVertex === to && edge.toVertex === from);
+        });
+        if (!edge) {
+            throw new Error("Edge not found");
+        }
+        return edge;
+    };
+    /**
+     * @inheritDoc
+     */
+    UndirectedGraph.prototype.hasEdge = function (from, to) {
+        return Boolean(this._edges.find(function (edge) {
+            return ((edge.fromVertex === from && edge.toVertex === to) ||
+                (edge.fromVertex === to && edge.toVertex === from));
+        }));
+    };
+    /**
+     * @inheritDoc
+     */
+    UndirectedGraph.prototype.addEdge = function (from, to, weight) {
+        var _a, _b;
+        try {
+            var fromVertex = this.tryFindVertex(from);
+            var toVertex = this.tryFindVertex(to);
+            /** When edge is already exist, we should only update its weight */
+            if (this.hasEdge(fromVertex, toVertex)) {
+                if (typeof weight === "number") {
+                    this.updateEdgeWeight(fromVertex, toVertex, weight);
+                }
+            }
+            else {
+                var edge = new GraphEdge_1.default(fromVertex, toVertex, weight);
+                this._edges.push(edge);
+                (_a = this._vertices.get(fromVertex)) === null || _a === void 0 ? void 0 : _a.push(toVertex);
+                (_b = this._vertices.get(toVertex)) === null || _b === void 0 ? void 0 : _b.push(fromVertex);
+            }
+        }
+        catch (_c) {
+            throw new Error("Edge cannot be added because one of vertices was not found");
+        }
+        return this;
+    };
+    /**
+     * @inheritDoc
+     */
+    UndirectedGraph.prototype.removeEdge = function (from, to) {
+        try {
+            var fromVertex_1 = this.tryFindVertex(from);
+            var toVertex_1 = this.tryFindVertex(to);
+            var edgeToRemove_1 = this.getEdgeByValue(fromVertex_1, toVertex_1);
+            var fromVertexNeighbors = this._vertices.get(fromVertex_1) || [];
+            var toVertexNeighbors = this._vertices.get(toVertex_1) || [];
+            var fromNewNeighbors = fromVertexNeighbors.filter(function (vertex) { return toVertex_1 !== vertex; });
+            var toNewNeighbors = toVertexNeighbors.filter(function (vertex) { return fromVertex_1 !== vertex; });
+            this._vertices.set(fromVertex_1, fromNewNeighbors);
+            this._vertices.set(toVertex_1, toNewNeighbors);
+            this._edges = this._edges.filter(function (edge) { return edge !== edgeToRemove_1; });
+        }
+        catch (_a) {
+            throw new Error("Edge cannot be removed because one of vertices was not found");
+        }
+        return this;
+    };
+    return UndirectedGraph;
+}(AbstractGraph_1.default));
+exports.default = UndirectedGraph;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/data-structures/Graph/demo/generateRandomGraph.d.ts

@@ -0,0 +1,4 @@
+import IGraph from "../../../types/IGraph";
+import { EnumGraphType } from "../../../types/EnumGraphType";
+import { EnumRandomGenerationFormat } from "../../../types/EnumRandomGenerationFormat";
+export declare const generateRandomGraph: (verticesCount: number, edgesCount: number, type?: EnumGraphType, format?: EnumRandomGenerationFormat) => IGraph<string>;

package/lib/data-structures/Graph/demo/generateRandomGraph.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRandomGraph = void 0;
+var EnumGraphType_1 = require("../../../types/EnumGraphType");
+var createGraph_1 = require("../../../helpers/createGraph");
+var utils_1 = require("../../../utils");
+var EnumRandomGenerationFormat_1 = require("../../../types/EnumRandomGenerationFormat");
+var getRandomVertex = function () {
+    return "_" + Math.random().toString(36).substr(2, 9);
+};
+var getPossibleEdgesCount = function (type, verticesCount) {
+    var possibleEdgesCount = verticesCount * (verticesCount - 1);
+    switch (type) {
+        case EnumGraphType_1.EnumGraphType.Directed: {
+            break;
+        }
+        case EnumGraphType_1.EnumGraphType.Undirected: {
+            possibleEdgesCount = Math.floor(possibleEdgesCount / 2);
+            break;
+        }
+        default: {
+            throw new Error("Wrong random generation format");
+        }
+    }
+    return possibleEdgesCount;
+};
+var fillGraphRandomly = function (graph, format, verticesCount) {
+    switch (format) {
+        case EnumRandomGenerationFormat_1.EnumRandomGenerationFormat.Hash: {
+            for (var i = 0; i < verticesCount; i++) {
+                graph.addVertex(getRandomVertex());
+            }
+            break;
+        }
+        case EnumRandomGenerationFormat_1.EnumRandomGenerationFormat.Numbers: {
+            for (var i = 0; i < verticesCount; i++) {
+                graph.addVertex((i + 1).toString());
+            }
+            break;
+        }
+        default: {
+            throw new Error("Wrong random generation format");
+        }
+    }
+};
+exports.generateRandomGraph = function (verticesCount, edgesCount, type, format) {
+    if (type === void 0) { type = EnumGraphType_1.EnumGraphType.Undirected; }
+    if (format === void 0) { format = EnumRandomGenerationFormat_1.EnumRandomGenerationFormat.Numbers; }
+    var graph = createGraph_1.createGraph(type);
+    var possibleEdgesCount = getPossibleEdgesCount(type, verticesCount);
+    if (edgesCount <= 0 || edgesCount > possibleEdgesCount) {
+        throw new Error("Edges count must be in range between 0 and " + possibleEdgesCount);
+    }
+    fillGraphRandomly(graph, format, verticesCount);
+    var addedVertices = graph.vertices();
+    var addedEdgesCount = 0;
+    while (addedEdgesCount < edgesCount) {
+        var randomizeIndex = function () {
+            return utils_1.randomizeNumberInRange(0, addedVertices.length);
+        };
+        var randomVertexFrom = addedVertices[randomizeIndex()];
+        var randomVertexTo = addedVertices[randomizeIndex()];
+        var isEdgeAlreadyExists = graph.hasEdge(randomVertexFrom, randomVertexTo);
+        var isTheSameVertex = randomVertexFrom === randomVertexTo;
+        if (!isTheSameVertex && !isEdgeAlreadyExists) {
+            graph.addEdge(randomVertexFrom, randomVertexTo);
+            addedEdgesCount++;
+        }
+    }
+    return graph;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/data-structures/Graph/iterator/AbstractGraphIterator.d.ts

@@ -0,0 +1,35 @@
+import IGraphIterator from "../../../types/IGraphIterator";
+import IGraph from "../../../types/IGraph";
+export default abstract class AbstractGraphIterator<T> implements IGraphIterator<T> {
+    protected readonly graph: IGraph<T>;
+    protected readonly visited: Map<T, boolean>;
+    protected readonly parents: Map<T, T>;
+    /**
+     * Creates empty instance
+     */
+    protected constructor(graph: IGraph<T>);
+    protected abstract currentImpl(): T;
+    protected abstract nextImpl(): T;
+    protected abstract initIteratorImpl(from: T): void;
+    protected abstract hasNextImpl(): boolean;
+    /**
+     * @inheritDoc
+     */
+    initIterator(from: T): void;
+    /**
+     * @inheritDoc
+     */
+    hasNext(): boolean;
+    /**
+     * @inheritDoc
+     */
+    next(): T;
+    /**
+     * @inheritDoc
+     */
+    current(): T;
+    /**
+     * @inheritDoc
+     */
+    getPath(from: T, to: T): Array<T>;
+}

package/lib/data-structures/Graph/iterator/AbstractGraphIterator.js

@@ -0,0 +1,90 @@
+"use strict";
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var AbstractGraphIterator = /** @class */ (function () {
+    /**
+     * Creates empty instance
+     */
+    function AbstractGraphIterator(graph) {
+        this.graph = graph;
+        this.visited = new Map();
+        this.parents = new Map();
+    }
+    /**
+     * @inheritDoc
+     */
+    AbstractGraphIterator.prototype.initIterator = function (from) {
+        if (!this.graph.hasVertex(from)) {
+            throw new Error("Start vertex does not exist");
+        }
+        this.initIteratorImpl(from);
+    };
+    /**
+     * @inheritDoc
+     */
+    AbstractGraphIterator.prototype.hasNext = function () {
+        return this.hasNextImpl();
+    };
+    /**
+     * @inheritDoc
+     */
+    AbstractGraphIterator.prototype.next = function () {
+        try {
+            if (!this.hasNext()) {
+                throw new Error();
+            }
+            return this.nextImpl();
+        }
+        catch (e) {
+            throw new Error("Next element does not exist");
+        }
+    };
+    /**
+     * @inheritDoc
+     */
+    AbstractGraphIterator.prototype.current = function () {
+        try {
+            var current = this.currentImpl();
+            if (current === null) {
+                throw new Error();
+            }
+            return current;
+        }
+        catch (e) {
+            throw new Error("Current element does not exist");
+        }
+    };
+    /**
+     * @inheritDoc
+     */
+    AbstractGraphIterator.prototype.getPath = function (from, to) {
+        var path = new Array();
+        var isLinkedDirectly = this.graph.hasEdge(from, to);
+        var currentVertex = this.parents.get(to);
+        if (isLinkedDirectly) {
+            return [from, to];
+        }
+        else {
+            while (currentVertex) {
+                if (currentVertex === from) {
+                    break;
+                }
+                path.push(currentVertex);
+                currentVertex = this.parents.get(currentVertex);
+            }
+            if (path.length === 0) {
+                throw new Error("There is no path found");
+            }
+            return __spreadArrays([from], path.reverse(), [to]);
+        }
+    };
+    return AbstractGraphIterator;
+}());
+exports.default = AbstractGraphIterator;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/data-structures/Graph/iterator/GraphIteratorBFS.d.ts

@@ -0,0 +1,28 @@
+import IGraph from "../../../types/IGraph";
+import AbstractGraphIterator from "./AbstractGraphIterator";
+/**
+ * Breadth first graph traversal
+ */
+export default class GraphIteratorBFS<T> extends AbstractGraphIterator<T> {
+    private readonly queue;
+    /**
+     * @inheritDoc
+     */
+    constructor(graph: IGraph<T>);
+    /**
+     * @inheritDoc
+     */
+    protected currentImpl(): T;
+    /**
+      @inheritDoc
+     */
+    initIteratorImpl(startVertex: T): void;
+    /**
+     * @inheritDoc
+     */
+    hasNextImpl(): boolean;
+    /**
+     * @inheritDoc
+     */
+    protected nextImpl(): T;
+}

package/lib/data-structures/Graph/iterator/GraphIteratorBFS.js

@@ -0,0 +1,70 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var Queue_1 = require("../../Queue/Queue");
+var AbstractGraphIterator_1 = require("./AbstractGraphIterator");
+/**
+ * Breadth first graph traversal
+ */
+var GraphIteratorBFS = /** @class */ (function (_super) {
+    __extends(GraphIteratorBFS, _super);
+    /**
+     * @inheritDoc
+     */
+    function GraphIteratorBFS(graph) {
+        var _this = _super.call(this, graph) || this;
+        _this.queue = new Queue_1.default();
+        return _this;
+    }
+    /**
+     * @inheritDoc
+     */
+    GraphIteratorBFS.prototype.currentImpl = function () {
+        return this.queue.peek();
+    };
+    /**
+      @inheritDoc
+     */
+    GraphIteratorBFS.prototype.initIteratorImpl = function (startVertex) {
+        this.queue.push(startVertex);
+        this.visited.set(startVertex, true);
+    };
+    /**
+     * @inheritDoc
+     */
+    GraphIteratorBFS.prototype.hasNextImpl = function () {
+        return !this.queue.isEmpty();
+    };
+    /**
+     * @inheritDoc
+     */
+    GraphIteratorBFS.prototype.nextImpl = function () {
+        var _this = this;
+        var next = this.queue.pop();
+        var nextNeighbors = this.graph.getVertexNeighbors(next);
+        nextNeighbors.forEach(function (neighbor) {
+            var isNotVisited = !_this.visited.get(neighbor);
+            if (isNotVisited) {
+                _this.queue.push(neighbor);
+                _this.visited.set(neighbor, true);
+                _this.parents.set(neighbor, next);
+            }
+        });
+        return next;
+    };
+    return GraphIteratorBFS;
+}(AbstractGraphIterator_1.default));
+exports.default = GraphIteratorBFS;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhJdGVyYXRvckJGUy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kYXRhLXN0cnVjdHVyZXMvR3JhcGgvaXRlcmF0b3IvR3JhcGhJdGVyYXRvckJGUy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7QUFBQSwyQ0FBc0M7QUFFdEMsaUVBQTREO0FBRTVEOztHQUVHO0FBQ0g7SUFBaUQsb0NBQXdCO0lBR3ZFOztPQUVHO0lBQ0gsMEJBQW1CLEtBQWdCO1FBQW5DLFlBQ0Usa0JBQU0sS0FBSyxDQUFDLFNBRWI7UUFEQyxLQUFJLENBQUMsS0FBSyxHQUFHLElBQUksZUFBSyxFQUFFLENBQUM7O0lBQzNCLENBQUM7SUFFRDs7T0FFRztJQUNPLHNDQUFXLEdBQXJCO1FBQ0UsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxDQUFDO0lBQzNCLENBQUM7SUFFRDs7T0FFRztJQUNJLDJDQUFnQixHQUF2QixVQUF3QixXQUFjO1FBQ3BDLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQzdCLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLFdBQVcsRUFBRSxJQUFJLENBQUMsQ0FBQztJQUN0QyxDQUFDO0lBRUQ7O09BRUc7SUFDSSxzQ0FBVyxHQUFsQjtRQUNFLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQy9CLENBQUM7SUFFRDs7T0FFRztJQUNPLG1DQUFRLEdBQWxCO1FBQUEsaUJBZUM7UUFkQyxJQUFNLElBQUksR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBQzlCLElBQU0sYUFBYSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsa0JBQWtCLENBQUMsSUFBSSxDQUFDLENBQUM7UUFFMUQsYUFBYSxDQUFDLE9BQU8sQ0FBQyxVQUFDLFFBQVE7WUFDN0IsSUFBTSxZQUFZLEdBQUcsQ0FBQyxLQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUVqRCxJQUFJLFlBQVksRUFBRTtnQkFDaEIsS0FBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7Z0JBQzFCLEtBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLFFBQVEsRUFBRSxJQUFJLENBQUMsQ0FBQztnQkFDakMsS0FBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxDQUFDO2FBQ2xDO1FBQ0gsQ0FBQyxDQUFDLENBQUM7UUFFSCxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7SUFDSCx1QkFBQztBQUFELENBQUMsQUFwREQsQ0FBaUQsK0JBQXFCLEdBb0RyRSJ9

package/lib/data-structures/Graph/iterator/GraphIteratorDFS.d.ts

@@ -0,0 +1,28 @@
+import IGraph from "../../../types/IGraph";
+import AbstractGraphIterator from "./AbstractGraphIterator";
+/**
+ * Deep first graph traversal
+ */
+export default class GraphIteratorDFS<T> extends AbstractGraphIterator<T> {
+    private readonly stack;
+    /**
+     * @inheritDoc
+     */
+    constructor(graph: IGraph<T>);
+    /**
+     * @inheritDoc
+     */
+    hasNextImpl(): boolean;
+    /**
+     @inheritDoc
+     */
+    initIteratorImpl(startVertex: T): void;
+    /**
+     * @inheritDoc
+     */
+    currentImpl(): T;
+    /**
+     * @inheritDoc
+     */
+    nextImpl(): T;
+}

package/lib/data-structures/Graph/iterator/GraphIteratorDFS.js

@@ -0,0 +1,70 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var Stack_1 = require("../../Stack/Stack");
+var AbstractGraphIterator_1 = require("./AbstractGraphIterator");
+/**
+ * Deep first graph traversal
+ */
+var GraphIteratorDFS = /** @class */ (function (_super) {
+    __extends(GraphIteratorDFS, _super);
+    /**
+     * @inheritDoc
+     */
+    function GraphIteratorDFS(graph) {
+        var _this = _super.call(this, graph) || this;
+        _this.stack = new Stack_1.default();
+        return _this;
+    }
+    /**
+     * @inheritDoc
+     */
+    GraphIteratorDFS.prototype.hasNextImpl = function () {
+        return !this.stack.isEmpty();
+    };
+    /**
+     @inheritDoc
+     */
+    GraphIteratorDFS.prototype.initIteratorImpl = function (startVertex) {
+        this.stack.push(startVertex);
+        this.visited.set(startVertex, true);
+    };
+    /**
+     * @inheritDoc
+     */
+    GraphIteratorDFS.prototype.currentImpl = function () {
+        return this.stack.peek();
+    };
+    /**
+     * @inheritDoc
+     */
+    GraphIteratorDFS.prototype.nextImpl = function () {
+        var _this = this;
+        var next = this.stack.pop();
+        var nextNeighbors = this.graph.getVertexNeighbors(next);
+        nextNeighbors.forEach(function (neighbor) {
+            var isNotVisited = !_this.visited.get(neighbor);
+            if (isNotVisited) {
+                _this.stack.push(neighbor);
+                _this.visited.set(neighbor, true);
+                _this.parents.set(neighbor, next);
+            }
+        });
+        return next;
+    };
+    return GraphIteratorDFS;
+}(AbstractGraphIterator_1.default));
+exports.default = GraphIteratorDFS;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhJdGVyYXRvckRGUy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kYXRhLXN0cnVjdHVyZXMvR3JhcGgvaXRlcmF0b3IvR3JhcGhJdGVyYXRvckRGUy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7QUFBQSwyQ0FBc0M7QUFFdEMsaUVBQTREO0FBRTVEOztHQUVHO0FBQ0g7SUFBaUQsb0NBQXdCO0lBR3ZFOztPQUVHO0lBQ0gsMEJBQW1CLEtBQWdCO1FBQW5DLFlBQ0Usa0JBQU0sS0FBSyxDQUFDLFNBRWI7UUFEQyxLQUFJLENBQUMsS0FBSyxHQUFHLElBQUksZUFBSyxFQUFFLENBQUM7O0lBQzNCLENBQUM7SUFFRDs7T0FFRztJQUNJLHNDQUFXLEdBQWxCO1FBQ0UsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxFQUFFLENBQUM7SUFDL0IsQ0FBQztJQUVEOztPQUVHO0lBQ0ksMkNBQWdCLEdBQXZCLFVBQXdCLFdBQWM7UUFDcEMsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDN0IsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsV0FBVyxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQ3RDLENBQUM7SUFFRDs7T0FFRztJQUNJLHNDQUFXLEdBQWxCO1FBQ0UsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxDQUFDO0lBQzNCLENBQUM7SUFFRDs7T0FFRztJQUNJLG1DQUFRLEdBQWY7UUFBQSxpQkFlQztRQWRDLElBQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDOUIsSUFBTSxhQUFhLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUUxRCxhQUFhLENBQUMsT0FBTyxDQUFDLFVBQUMsUUFBUTtZQUM3QixJQUFNLFlBQVksR0FBRyxDQUFDLEtBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBRWpELElBQUksWUFBWSxFQUFFO2dCQUNoQixLQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztnQkFDMUIsS0FBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxDQUFDO2dCQUNqQyxLQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxRQUFRLEVBQUUsSUFBSSxDQUFDLENBQUM7YUFDbEM7UUFDSCxDQUFDLENBQUMsQ0FBQztRQUVILE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUNILHVCQUFDO0FBQUQsQ0FBQyxBQXBERCxDQUFpRCwrQkFBcUIsR0FvRHJFIn0=

package/lib/data-structures/Graph/iterator/GraphIteratorDijkstra.d.ts

@@ -0,0 +1,32 @@
+import IGraph from "../../../types/IGraph";
+import AbstractGraphIterator from "./AbstractGraphIterator";
+/**
+ * Dijkstra method graph traversal
+ */
+export default class GraphIteratorDijkstra<T> extends AbstractGraphIterator<T> {
+    private readonly costs;
+    /**
+     * @inheritDoc
+     */
+    constructor(graph: IGraph<T>);
+    /**
+     * Get not visited vertex with minimal cost
+     */
+    private getClosestNotVisited;
+    /**
+     * @inheritDoc
+     */
+    initIteratorImpl(startVertex: T): void;
+    /**
+     * @inheritDoc
+     */
+    hasNextImpl(): boolean;
+    /**
+     * @inheritDoc
+     */
+    currentImpl(): T;
+    /**
+     * @inheritDoc
+     */
+    nextImpl(): T;
+}

package/lib/data-structures/Graph/iterator/GraphIteratorDijkstra.js

@@ -0,0 +1,99 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var AbstractGraphIterator_1 = require("./AbstractGraphIterator");
+/**
+ * Dijkstra method graph traversal
+ */
+var GraphIteratorDijkstra = /** @class */ (function (_super) {
+    __extends(GraphIteratorDijkstra, _super);
+    /**
+     * @inheritDoc
+     */
+    function GraphIteratorDijkstra(graph) {
+        var _this = _super.call(this, graph) || this;
+        _this.costs = new Map();
+        return _this;
+    }
+    /**
+     * Get not visited vertex with minimal cost
+     */
+    GraphIteratorDijkstra.prototype.getClosestNotVisited = function () {
+        var _this = this;
+        var keys = Array.from(this.costs.keys());
+        var priorityList = keys
+            .filter(function (key) { return !_this.visited.get(key); })
+            .sort(function (aKey, bKey) {
+            var aCost = _this.costs.get(aKey) || 0;
+            var bCost = _this.costs.get(bKey) || 0;
+            return aCost - bCost;
+        });
+        if (priorityList[0] === undefined) {
+            throw new Error("No more vertices found");
+        }
+        return priorityList[0];
+    };
+    /**
+     * @inheritDoc
+     */
+    GraphIteratorDijkstra.prototype.initIteratorImpl = function (startVertex) {
+        var _this = this;
+        if (!this.graph.hasVertex(startVertex)) {
+            throw new Error("Start vertex does not exist");
+        }
+        this.visited.set(startVertex, true);
+        this.costs.set(startVertex, 0);
+        this.graph.getVertexNeighbors(startVertex).forEach(function (neighbor) {
+            var edgeWeight = _this.graph.getEdgeWeight(startVertex, neighbor);
+            _this.costs.set(neighbor, edgeWeight);
+            _this.parents.set(neighbor, startVertex);
+        });
+    };
+    /**
+     * @inheritDoc
+     */
+    GraphIteratorDijkstra.prototype.hasNextImpl = function () {
+        return !(this.getClosestNotVisited() === null);
+    };
+    /**
+     * @inheritDoc
+     */
+    GraphIteratorDijkstra.prototype.currentImpl = function () {
+        return this.getClosestNotVisited();
+    };
+    /**
+     * @inheritDoc
+     */
+    GraphIteratorDijkstra.prototype.nextImpl = function () {
+        var _this = this;
+        var next = this.getClosestNotVisited();
+        this.visited.set(next, true);
+        var nextNeighbors = this.graph.getVertexNeighbors(next);
+        var nextCost = this.costs.get(next);
+        nextNeighbors.forEach(function (neighbor) {
+            var edgeWeight = _this.graph.getEdgeWeight(next, neighbor);
+            var currentNeighborCost = _this.costs.get(neighbor) || Infinity;
+            var newNeighborCost = (nextCost || 0) + edgeWeight;
+            if (newNeighborCost < currentNeighborCost) {
+                _this.costs.set(neighbor, newNeighborCost);
+                _this.parents.set(neighbor, next);
+            }
+        });
+        return next;
+    };
+    return GraphIteratorDijkstra;
+}(AbstractGraphIterator_1.default));
+exports.default = GraphIteratorDijkstra;
+//# sourceMappingURL=data:application/json;base64,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