data-structure-typed 0.8.6

package/dist/data-structures/graph/directed-graph.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectedGraph = exports.DirectedEdge = exports.DirectedVertex = void 0;
+const utils_1 = require("../../utils");
+const abstract_graph_1 = require("./abstract-graph");
+class DirectedVertex extends abstract_graph_1.AbstractVertex {
+    constructor(id) {
+        super(id);
+    }
+}
+exports.DirectedVertex = DirectedVertex;
+class DirectedEdge extends abstract_graph_1.AbstractEdge {
+    constructor(src, dest, weight) {
+        super(weight);
+        this._src = src;
+        this._dest = dest;
+    }
+    get src() {
+        return this._src;
+    }
+    set src(v) {
+        this._src = v;
+    }
+    get dest() {
+        return this._dest;
+    }
+    set dest(v) {
+        this._dest = v;
+    }
+}
+exports.DirectedEdge = DirectedEdge;
+// Strongly connected, One direction connected, Weakly connected
+class DirectedGraph extends abstract_graph_1.AbstractGraph {
+    constructor() {
+        super();
+        this._outEdgeMap = new Map();
+        this._inEdgeMap = new Map();
+    }
+    getEdge(srcOrId, destOrId) {
+        let edges = [];
+        if (srcOrId !== null && destOrId !== null) {
+            const src = this.getVertex(srcOrId);
+            const dest = this.getVertex(destOrId);
+            if (src && dest) {
+                const srcOutEdges = this._outEdgeMap.get(src);
+                if (srcOutEdges) {
+                    edges = srcOutEdges.filter(edge => edge.dest === dest.id);
+                }
+            }
+        }
+        return edges[0] || null;
+    }
+    addEdge(edge) {
+        if (!(this.containsVertex(edge.src) && this.containsVertex(edge.dest))) {
+            return false;
+        }
+        const srcVertex = this.getVertex(edge.src);
+        const destVertex = this.getVertex(edge.dest);
+        // TODO after no-non-null-assertion not ensure the logic
+        if (srcVertex && destVertex) {
+            const srcOutEdges = this._outEdgeMap.get(srcVertex);
+            if (srcOutEdges) {
+                srcOutEdges.push(edge);
+            }
+            else {
+                this._outEdgeMap.set(srcVertex, [edge]);
+            }
+            const destInEdges = this._inEdgeMap.get(destVertex);
+            if (destInEdges) {
+                destInEdges.push(edge);
+            }
+            else {
+                this._inEdgeMap.set(destVertex, [edge]);
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    removeEdgeBetween(srcOrId, destOrId) {
+        const src = this.getVertex(srcOrId);
+        const dest = this.getVertex(destOrId);
+        let removed = null;
+        if (!src || !dest) {
+            return null;
+        }
+        const srcOutEdges = this._outEdgeMap.get(src);
+        if (srcOutEdges) {
+            (0, utils_1.arrayRemove)(srcOutEdges, edge => edge.dest === dest.id);
+        }
+        const destInEdges = this._inEdgeMap.get(dest);
+        if (destInEdges) {
+            removed = (0, utils_1.arrayRemove)(destInEdges, edge => edge.src === src.id)[0] || null;
+        }
+        return removed;
+    }
+    removeEdge(edge) {
+        let removed = null;
+        const src = this.getVertex(edge.src);
+        const dest = this.getVertex(edge.dest);
+        if (src && dest) {
+            const srcOutEdges = this._outEdgeMap.get(src);
+            if (srcOutEdges && srcOutEdges.length > 0) {
+                (0, utils_1.arrayRemove)(srcOutEdges, edge => edge.src === src.id);
+            }
+            const destInEdges = this._inEdgeMap.get(dest);
+            if (destInEdges && destInEdges.length > 0) {
+                removed = (0, utils_1.arrayRemove)(destInEdges, edge => edge.dest === dest.id)[0];
+            }
+        }
+        return removed;
+    }
+    removeAllEdges(src, dest) {
+        return [];
+    }
+    incomingEdgesOf(vertexOrId) {
+        const target = this.getVertex(vertexOrId);
+        if (target) {
+            return this._inEdgeMap.get(target) || [];
+        }
+        return [];
+    }
+    outgoingEdgesOf(vertexOrId) {
+        const target = this.getVertex(vertexOrId);
+        if (target) {
+            return this._outEdgeMap.get(target) || [];
+        }
+        return [];
+    }
+    degreeOf(vertexOrId) {
+        return this.outDegreeOf(vertexOrId) + this.inDegreeOf(vertexOrId);
+    }
+    inDegreeOf(vertexOrId) {
+        return this.incomingEdgesOf(vertexOrId).length;
+    }
+    outDegreeOf(vertexOrId) {
+        return this.outgoingEdgesOf(vertexOrId).length;
+    }
+    edgesOf(vertexOrId) {
+        return [...this.outgoingEdgesOf(vertexOrId), ...this.incomingEdgesOf(vertexOrId)];
+    }
+    getEdgeSrc(e) {
+        return this.getVertex(e.src);
+    }
+    getEdgeDest(e) {
+        return this.getVertex(e.dest);
+    }
+    getDestinations(vertex) {
+        if (vertex === null) {
+            return [];
+        }
+        const destinations = [];
+        const outgoingEdges = this.outgoingEdgesOf(vertex);
+        for (const outEdge of outgoingEdges) {
+            const child = this.getEdgeDest(outEdge);
+            if (child) {
+                destinations.push(child);
+            }
+        }
+        return destinations;
+    }
+    /**--- start find cycles --- */
+    /**
+     * when stored with adjacency list time: O(V+E)
+     * when stored with adjacency matrix time: O(V^2)
+     */
+    topologicalSort() {
+        // vector<vector<int>> g;
+        // vector<int> color;
+        // int last;
+        // bool hasCycle;
+        //
+        // bool topo_sort() {
+        //     int n = g.size();
+        //     vector<int> degree(n, 0);
+        //     queue<int> q;
+        //     for (int i = 0; i < n; i++) {
+        //         degree[i] = g[i].size();
+        //         if (degree[i] <= 1) {
+        //             q.push(i);
+        //         }
+        //     }
+        //     int cnt = 0;
+        //     while (!q.empty()) {
+        //         cnt++;
+        //         int root = q.front();
+        //         q.pop();
+        //         for (auto child : g[root]) {
+        //             degree[child]--;
+        //             if (degree[child] == 1) {
+        //                 q.push(child);
+        //             }
+        //         }
+        //     }
+        //     return (cnt != n);
+        // }
+        // When judging whether there is a cycle in the undirected graph, all nodes with degree of **<= 1** are enqueued
+        // When judging whether there is a cycle in the directed graph, all nodes with **in degree = 0** are enqueued
+        const statusMap = new Map();
+        for (const entry of this._vertices) {
+            statusMap.set(entry[1], 0);
+        }
+        const sorted = [];
+        let hasCycle = false;
+        const dfs = (cur) => {
+            statusMap.set(cur, 1);
+            const children = this.getDestinations(cur);
+            for (const child of children) {
+                const childStatus = statusMap.get(child);
+                if (childStatus === 0) {
+                    dfs(child);
+                }
+                else if (childStatus === 1) {
+                    hasCycle = true;
+                }
+            }
+            statusMap.set(cur, 2);
+            sorted.push(cur);
+        };
+        for (const entry of this._vertices) {
+            if (statusMap.get(entry[1]) === 0) {
+                dfs(entry[1]);
+            }
+        }
+        if (hasCycle) {
+            return null;
+        }
+        return sorted.reverse();
+    }
+    /**--- end find cycles --- */
+    edgeSet() {
+        let edges = [];
+        this._outEdgeMap.forEach(outEdges => {
+            edges = [...edges, ...outEdges];
+        });
+        return edges;
+    }
+    getNeighbors(vertexOrId) {
+        const neighbors = [];
+        const vertex = this.getVertex(vertexOrId);
+        if (vertex) {
+            const outEdges = this.outgoingEdgesOf(vertex);
+            for (const outEdge of outEdges) {
+                const neighbor = this.getVertex(outEdge.dest);
+                // TODO after no-non-null-assertion not ensure the logic
+                if (neighbor) {
+                    neighbors.push(neighbor);
+                }
+            }
+        }
+        return neighbors;
+    }
+    getEndsOfEdge(edge) {
+        if (!this.containsEdge(edge.src, edge.dest)) {
+            return null;
+        }
+        const v1 = this.getVertex(edge.src);
+        const v2 = this.getVertex(edge.dest);
+        if (v1 && v2) {
+            return [v1, v2];
+        }
+        else {
+            return null;
+        }
+    }
+}
+exports.DirectedGraph = DirectedGraph;

package/dist/data-structures/graph/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./abstract-graph"), exports);
+__exportStar(require("./directed-graph"), exports);
+__exportStar(require("./undirected-graph"), exports);

package/dist/data-structures/graph/undirected-graph.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndirectedGraph = exports.UndirectedEdge = exports.UndirectedVertex = void 0;
+const utils_1 = require("../../utils");
+const abstract_graph_1 = require("./abstract-graph");
+class UndirectedVertex extends abstract_graph_1.AbstractVertex {
+    constructor(id) {
+        super(id);
+    }
+}
+exports.UndirectedVertex = UndirectedVertex;
+class UndirectedEdge extends abstract_graph_1.AbstractEdge {
+    get vertices() {
+        return this._vertices;
+    }
+    set vertices(v) {
+        this._vertices = v;
+    }
+    constructor(v1, v2, weight) {
+        super(weight);
+        this._vertices = [v1, v2];
+    }
+}
+exports.UndirectedEdge = UndirectedEdge;
+class UndirectedGraph extends abstract_graph_1.AbstractGraph {
+    constructor() {
+        super();
+        this._edges = new Map();
+    }
+    getEdge(v1, v2) {
+        var _a;
+        let edges = [];
+        if (v1 !== null && v2 !== null) {
+            const vertex1 = this.getVertex(v1);
+            const vertex2 = this.getVertex(v2);
+            if (vertex1 && vertex2) {
+                edges = (_a = this._edges.get(vertex1)) === null || _a === void 0 ? void 0 : _a.filter(e => e.vertices.includes(vertex2.id));
+            }
+        }
+        return edges ? edges[0] || null : null;
+    }
+    addEdge(edge) {
+        for (const end of edge.vertices) {
+            const endVertex = this.getVertex(end);
+            if (endVertex === null)
+                return false;
+            if (endVertex) {
+                const edges = this._edges.get(endVertex);
+                if (edges) {
+                    edges.push(edge);
+                }
+                else {
+                    this._edges.set(endVertex, [edge]);
+                }
+            }
+        }
+        return true;
+    }
+    removeEdgeBetween(v1, v2) {
+        const vertex1 = this.getVertex(v1);
+        const vertex2 = this.getVertex(v2);
+        if (!vertex1 || !vertex2) {
+            return null;
+        }
+        const v1Edges = this._edges.get(vertex1);
+        let removed = null;
+        if (v1Edges) {
+            removed = (0, utils_1.arrayRemove)(v1Edges, e => e.vertices.includes(vertex2.id))[0] || null;
+        }
+        const v2Edges = this._edges.get(vertex2);
+        if (v2Edges) {
+            (0, utils_1.arrayRemove)(v2Edges, e => e.vertices.includes(vertex1.id));
+        }
+        return removed;
+    }
+    removeEdge(edge) {
+        return this.removeEdgeBetween(edge.vertices[0], edge.vertices[1]);
+    }
+    degreeOf(vertexOrId) {
+        var _a;
+        const vertex = this.getVertex(vertexOrId);
+        if (vertex) {
+            return ((_a = this._edges.get(vertex)) === null || _a === void 0 ? void 0 : _a.length) || 0;
+        }
+        else {
+            return 0;
+        }
+    }
+    edgesOf(vertexOrId) {
+        const vertex = this.getVertex(vertexOrId);
+        if (vertex) {
+            return this._edges.get(vertex) || [];
+        }
+        else {
+            return [];
+        }
+    }
+    edgeSet() {
+        const edgeSet = new Set();
+        this._edges.forEach(edges => {
+            edges.forEach(edge => {
+                edgeSet.add(edge);
+            });
+        });
+        return [...edgeSet];
+    }
+    getEdgesOf(vertexOrId) {
+        const vertex = this.getVertex(vertexOrId);
+        if (!vertex) {
+            return [];
+        }
+        return this._edges.get(vertex) || [];
+    }
+    getNeighbors(vertexOrId) {
+        const neighbors = [];
+        const vertex = this.getVertex(vertexOrId);
+        if (vertex) {
+            const neighborEdges = this.getEdgesOf(vertex);
+            for (const edge of neighborEdges) {
+                const neighbor = this.getVertex(edge.vertices.filter(e => e !== vertex.id)[0]);
+                if (neighbor) {
+                    neighbors.push(neighbor);
+                }
+            }
+        }
+        return neighbors;
+    }
+    getEndsOfEdge(edge) {
+        if (!this.containsEdge(edge.vertices[0], edge.vertices[1])) {
+            return null;
+        }
+        const v1 = this.getVertex(edge.vertices[0]);
+        const v2 = this.getVertex(edge.vertices[1]);
+        if (v1 && v2) {
+            return [v1, v2];
+        }
+        else {
+            return null;
+        }
+    }
+}
+exports.UndirectedGraph = UndirectedGraph;

package/dist/data-structures/hash/coordinate-map.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoordinateSet = void 0;
+class CoordinateSet extends Map {
+    constructor(joint) {
+        super();
+        this._joint = '_';
+        if (joint !== undefined)
+            this._joint = joint;
+    }
+    has(key) {
+        return super.has(key.join(this._joint));
+    }
+    set(key, value) {
+        return super.set(key.join(this._joint), value);
+    }
+    get(key) {
+        return super.get(key.join(this._joint));
+    }
+    delete(key) {
+        return super.delete(key.join(this._joint));
+    }
+}
+exports.CoordinateSet = CoordinateSet;

package/dist/data-structures/hash/coordinate-set.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoordinateSet = void 0;
+class CoordinateSet extends Set {
+    constructor(joint) {
+        super();
+        this._joint = '_';
+        if (joint !== undefined)
+            this._joint = joint;
+    }
+    has(value) {
+        return super.has(value.join(this._joint));
+    }
+    add(value) {
+        return super.add(value.join(this._joint));
+    }
+    delete(value) {
+        return super.delete(value.join(this._joint));
+    }
+}
+exports.CoordinateSet = CoordinateSet;

package/dist/data-structures/hash/hash-table.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/hash/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hash-table"), exports);

package/dist/data-structures/hash/pair.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/hash/tree-map.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/hash/tree-set.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/heap/heap.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Heap = void 0;
+/**
+ * @copyright 2021 Pablo Rios <zrwusa@gmail.com>
+ * @license MIT
+ *
+ * @abstract
+ * @class Heap
+ */
+class Heap {
+    /**
+     * Creates a priority queue
+     * @public
+     * @params {object} [options]
+     */
+    constructor(options) {
+        if (options) {
+            const { priority } = options;
+            if (priority !== undefined && typeof priority !== 'function') {
+                throw new Error('.constructor expects a valid priority function');
+            }
+            this._priorityCb = priority || ((el) => +el);
+        }
+        else {
+            this._priorityCb = (el) => +el;
+        }
+    }
+    /**
+     * @public
+     * @returns {number}
+     */
+    get size() {
+        return this._pq.size;
+    }
+    /**
+     * @public
+     * @returns {boolean}
+     */
+    isEmpty() {
+        return this._pq.size < 1;
+    }
+    /**
+     * Returns an element with highest priority in the queue
+     * @public
+     * @returns {object}
+     */
+    peek() {
+        return this._pq.peek();
+    }
+    /**
+     * Returns an element with lowest priority in the queue
+     * @public
+     * @returns {object}
+     */
+    peekLast() {
+        return this._pq.leaf();
+    }
+    /**
+     * Adds an element to the queue
+     * @public
+     * @param {any} element
+     * @param priority
+     * @throws {Error} if priority is not a valid number
+     */
+    offer(element, priority) {
+        if (typeof element === 'number') {
+            priority = element;
+        }
+        else {
+            if (priority === undefined) {
+                throw new Error('.offer expects a numeric priority');
+            }
+        }
+        if (priority && Number.isNaN(+priority)) {
+            throw new Error('.offer expects a numeric priority');
+        }
+        if (Number.isNaN(+priority) && Number.isNaN(this._priorityCb(element))) {
+            throw new Error('.offer expects a numeric priority '
+                + 'or a constructor callback that returns a number');
+        }
+        const _priority = !Number.isNaN(+priority) ? priority : this._priorityCb(element);
+        this._pq.offer({ priority: _priority, element });
+        return this;
+    }
+    /**
+     * Removes and returns an element with highest priority in the queue
+     * @public
+     * @returns {object}
+     */
+    poll() {
+        const top = this._pq.poll();
+        if (!top) {
+            return null;
+        }
+        return top;
+    }
+    /**
+     * Returns a sorted list of elements
+     * @public
+     * @returns {array}
+     */
+    toArray() {
+        return this._pq.toArray();
+    }
+    /**
+     * Clears the queue
+     * @public
+     */
+    clear() {
+        this._pq.clear();
+    }
+}
+exports.Heap = Heap;

package/dist/data-structures/heap/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./max-heap"), exports);
+__exportStar(require("./min-heap"), exports);
+__exportStar(require("./heap"), exports);

package/dist/data-structures/heap/max-heap.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ * @license MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaxHeap = void 0;
+const heap_1 = require("./heap");
+const priority_queue_1 = require("../priority-queue");
+/**
+ * @class MaxHeap
+ * @extends Heap
+ */
+class MaxHeap extends heap_1.Heap {
+    constructor(options) {
+        super(options);
+        this._pq = new priority_queue_1.PriorityQueue({
+            comparator: (a, b) => b.priority - a.priority
+        });
+    }
+}
+exports.MaxHeap = MaxHeap;

package/dist/data-structures/heap/min-heap.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ * @license MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinHeap = void 0;
+const heap_1 = require("./heap");
+const priority_queue_1 = require("../priority-queue");
+/**
+ * @class MinHeap
+ * @extends Heap
+ */
+class MinHeap extends heap_1.Heap {
+    constructor(options) {
+        super(options);
+        this._pq = new priority_queue_1.PriorityQueue({
+            comparator: (a, b) => a.priority - b.priority
+        });
+    }
+}
+exports.MinHeap = MinHeap;