data-structure-typed 0.8.18 → 0.9.16

package/dist/data-structures/binary-tree/segment-tree.js

@@ -1,44 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SegmentTree = exports.SegmentTreeNode = void 0;
-class SegmentTreeNode {
-    get start() {
-        return this._start;
-    }
-    set start(v) {
-        this._start = v;
-    }
-    get end() {
-        return this._end;
-    }
-    set end(v) {
-        this._end = v;
-    }
-    get val() {
-        return this._val;
-    }
-    set val(v) {
-        this._val = v;
-    }
-    get sum() {
-        return this._sum;
-    }
-    set sum(v) {
-        this._sum = v;
-    }
-    get left() {
-        return this._left;
-    }
-    set left(v) {
-        this._left = v;
-    }
-    get right() {
-        return this._right;
-    }
-    set right(v) {
-        this._right = v;
-    }
-    constructor(start, end, sum, val) {
+var SegmentTreeNode = /** @class */ (function () {
+    function SegmentTreeNode(start, end, sum, val) {
         this._start = 0;
         this._end = 0;
         this._val = null;
@@ -50,13 +14,71 @@ class SegmentTreeNode {
         this._sum = sum;
         this._val = val || null;
     }
-}
+    Object.defineProperty(SegmentTreeNode.prototype, "start", {
+        get: function () {
+            return this._start;
+        },
+        set: function (v) {
+            this._start = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SegmentTreeNode.prototype, "end", {
+        get: function () {
+            return this._end;
+        },
+        set: function (v) {
+            this._end = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SegmentTreeNode.prototype, "val", {
+        get: function () {
+            return this._val;
+        },
+        set: function (v) {
+            this._val = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SegmentTreeNode.prototype, "sum", {
+        get: function () {
+            return this._sum;
+        },
+        set: function (v) {
+            this._sum = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SegmentTreeNode.prototype, "left", {
+        get: function () {
+            return this._left;
+        },
+        set: function (v) {
+            this._left = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SegmentTreeNode.prototype, "right", {
+        get: function () {
+            return this._right;
+        },
+        set: function (v) {
+            this._right = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return SegmentTreeNode;
+}());
 exports.SegmentTreeNode = SegmentTreeNode;
-class SegmentTree {
-    get root() {
-        return this._root;
-    }
-    constructor(values, start, end) {
+var SegmentTree = /** @class */ (function () {
+    function SegmentTree(values, start, end) {
         this._values = [];
         this._start = 0;
         start = start || 0;
@@ -66,30 +88,37 @@ class SegmentTree {
         this._end = end;
         this._root = this.build(start, end);
     }
-    build(start, end) {
+    Object.defineProperty(SegmentTree.prototype, "root", {
+        get: function () {
+            return this._root;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    SegmentTree.prototype.build = function (start, end) {
         if (start === end) {
             return new SegmentTreeNode(start, end, this._values[start]);
         }
-        const mid = start + Math.floor((end - start) / 2);
-        const left = this.build(start, mid);
-        const right = this.build(mid + 1, end);
-        const cur = new SegmentTreeNode(start, end, left.sum + right.sum);
+        var mid = start + Math.floor((end - start) / 2);
+        var left = this.build(start, mid);
+        var right = this.build(mid + 1, end);
+        var cur = new SegmentTreeNode(start, end, left.sum + right.sum);
         cur.left = left;
         cur.right = right;
         return cur;
-    }
-    updateNode(index, sum, val) {
-        const root = this.root || null;
+    };
+    SegmentTree.prototype.updateNode = function (index, sum, val) {
+        var root = this.root || null;
         if (!root) {
             return;
         }
-        const dfs = (cur, index, sum, val) => {
+        var dfs = function (cur, index, sum, val) {
             if (cur.start === cur.end && cur.start === index) {
                 cur.sum = sum;
                 // cur.val = val;
                 return;
             }
-            const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
+            var mid = cur.start + Math.floor((cur.end - cur.start) / 2);
             if (index <= mid) {
                 if (cur.left) {
                     dfs(cur.left, index, sum, val);
@@ -105,17 +134,17 @@ class SegmentTree {
             }
         };
         dfs(root, index, sum);
-    }
-    querySumByRange(indexA, indexB) {
-        const root = this.root || null;
+    };
+    SegmentTree.prototype.querySumByRange = function (indexA, indexB) {
+        var root = this.root || null;
         if (!root) {
             return 0;
         }
-        const dfs = (cur, i, j) => {
+        var dfs = function (cur, i, j) {
             if (cur.start === i && cur.end === j) {
                 return cur.sum;
             }
-            const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
+            var mid = cur.start + Math.floor((cur.end - cur.start) / 2);
             if (j <= mid) {
                 // TODO after no-non-null-assertion not ensure the logic
                 if (cur.left) {
@@ -146,6 +175,7 @@ class SegmentTree {
             }
         };
         return dfs(root, indexA, indexB);
-    }
-}
+    };
+    return SegmentTree;
+}());
 exports.SegmentTree = SegmentTree;

package/dist/data-structures/binary-tree/splay-tree.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SplayTree = void 0;
-class SplayTree {
-}
+var SplayTree = /** @class */ (function () {
+    function SplayTree() {
+    }
+    return SplayTree;
+}());
 exports.SplayTree = SplayTree;

package/dist/data-structures/binary-tree/tree-multiset.d.ts

@@ -1,9 +1,5 @@
 import { BST, BSTNode } from './bst';
-import { BinaryTreeNodeId } from './binary-tree';
-export type TreeMultiSetDeletedResult<T> = {
-    deleted: BSTNode<T> | null;
-    needBalanced: BSTNode<T> | null;
-};
+import type { BinaryTreeNodeId, TreeMultiSetDeletedResult } from '../types';
 export declare class TreeMultiSet<T> extends BST<T> {
     createNode(id: BinaryTreeNodeId, val: T, count?: number): BSTNode<T>;
     put(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;

package/dist/data-structures/binary-tree/tree-multiset.js

@@ -1,16 +1,36 @@
 "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) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeMultiSet = void 0;
-const bst_1 = require("./bst");
-class TreeMultiSet extends bst_1.BST {
-    createNode(id, val, count) {
-        return new bst_1.BSTNode(id, val, count);
-    }
-    put(id, val, count) {
-        return super.put(id, val, count);
+var bst_1 = require("./bst");
+var TreeMultiSet = /** @class */ (function (_super) {
+    __extends(TreeMultiSet, _super);
+    function TreeMultiSet() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-    remove(id, isUpdateAllLeftSum) {
-        return super.remove(id, isUpdateAllLeftSum);
-    }
-}
+    TreeMultiSet.prototype.createNode = function (id, val, count) {
+        return new bst_1.BSTNode(id, val, count);
+    };
+    TreeMultiSet.prototype.put = function (id, val, count) {
+        return _super.prototype.put.call(this, id, val, count);
+    };
+    TreeMultiSet.prototype.remove = function (id, isUpdateAllLeftSum) {
+        return _super.prototype.remove.call(this, id, isUpdateAllLeftSum);
+    };
+    return TreeMultiSet;
+}(bst_1.BST));
 exports.TreeMultiSet = TreeMultiSet;

package/dist/data-structures/binary-tree/two-three-tree.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TwoThreeTree = void 0;
-class TwoThreeTree {
-}
+var TwoThreeTree = /** @class */ (function () {
+    function TwoThreeTree() {
+    }
+    return TwoThreeTree;
+}());
 exports.TwoThreeTree = TwoThreeTree;

package/dist/data-structures/graph/abstract-graph.d.ts

@@ -1,49 +1,21 @@
-export type VertexId = string | number;
-export type DijkstraResult<V> = {
-    distMap: Map<V, number>;
-    preMap: Map<V, V | null>;
-    seen: Set<V>;
-    paths: V[][];
-    minDist: number;
-    minPath: V[];
-} | null;
-export interface I_Graph<V, E> {
-    containsVertex(vertexOrId: V | VertexId): boolean;
-    getVertex(vertexOrId: VertexId | V): V | null;
-    getVertexId(vertexOrId: V | VertexId): VertexId;
-    vertexSet(): Map<VertexId, V>;
-    addVertex(v: V): boolean;
-    removeVertex(vertexOrId: V | VertexId): boolean;
-    removeAllVertices(vertices: V[] | VertexId[]): boolean;
-    degreeOf(vertexOrId: V | VertexId): number;
-    edgesOf(vertexOrId: V | VertexId): E[];
-    containsEdge(src: V | VertexId, dest: V | VertexId): boolean;
-    getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
-    edgeSet(): E[];
-    addEdge(edge: E): boolean;
-    removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
-    removeEdge(edge: E): E | null;
-    setEdgeWeight(srcOrId: V | VertexId, destOrId: V | VertexId, weight: number): boolean;
-    getMinPathBetween(v1: V | VertexId, v2: V | VertexId, isWeight?: boolean): V[] | null;
-    getNeighbors(vertexOrId: V | VertexId): V[];
-}
+import type { DijkstraResult, IGraph, VertexId } from '../types';
 export declare class AbstractVertex {
+    constructor(id: VertexId);
     private _id;
     get id(): VertexId;
     set id(v: VertexId);
-    constructor(id: VertexId);
 }
 export declare abstract class AbstractEdge {
+    static DEFAULT_EDGE_WEIGHT: number;
+    protected constructor(weight?: number);
     private _weight;
     get weight(): number;
     set weight(v: number);
     private _hashCode;
     get hashCode(): string;
     set hashCode(v: string);
-    protected constructor(weight?: number);
-    static DEFAULT_EDGE_WEIGHT: number;
 }
-export declare abstract class AbstractGraph<V extends AbstractVertex, E extends AbstractEdge> implements I_Graph<V, E> {
+export declare abstract class AbstractGraph<V extends AbstractVertex, E extends AbstractEdge> implements IGraph<V, E> {
     protected _vertices: Map<VertexId, V>;
     abstract removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
     abstract removeEdge(edge: E): E | null;