data-structure-typed 1.19.2 → 1.19.4

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

@@ -8,8 +8,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SegmentTree = exports.SegmentTreeNode = void 0;
-var SegmentTreeNode = /** @class */ (function () {
-    function SegmentTreeNode(start, end, sum, val) {
+class SegmentTreeNode {
+    constructor(start, end, sum, val) {
         this._start = 0;
         this._end = 0;
         this._val = null;
@@ -21,70 +21,45 @@ var SegmentTreeNode = /** @class */ (function () {
         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;
-}());
+    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;
+    }
+}
 exports.SegmentTreeNode = SegmentTreeNode;
-var SegmentTree = /** @class */ (function () {
+class SegmentTree {
     /**
      * The constructor initializes the values, start, end, and root properties of an object.
      * @param {number[]} values - An array of numbers that will be used to build a binary search tree.
@@ -94,7 +69,7 @@ var SegmentTree = /** @class */ (function () {
      * @param {number} [end] - The "end" parameter is the index of the last element in the "values" array that should be
      * included in the range. If not provided, it defaults to the index of the last element in the "values" array.
      */
-    function SegmentTree(values, start, end) {
+    constructor(values, start, end) {
         this._values = [];
         this._start = 0;
         start = start || 0;
@@ -104,34 +79,18 @@ var SegmentTree = /** @class */ (function () {
         this._end = end;
         this._root = this.build(start, end);
     }
-    Object.defineProperty(SegmentTree.prototype, "values", {
-        get: function () {
-            return this._values;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SegmentTree.prototype, "start", {
-        get: function () {
-            return this._start;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SegmentTree.prototype, "end", {
-        get: function () {
-            return this._end;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SegmentTree.prototype, "root", {
-        get: function () {
-            return this._root;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    get values() {
+        return this._values;
+    }
+    get start() {
+        return this._start;
+    }
+    get end() {
+        return this._end;
+    }
+    get root() {
+        return this._root;
+    }
     /**
      * The function builds a segment tree by recursively dividing the given range into smaller segments and creating nodes
      * for each segment.
@@ -141,17 +100,17 @@ var SegmentTree = /** @class */ (function () {
      * building the segment tree.
      * @returns a SegmentTreeNode object.
      */
-    SegmentTree.prototype.build = function (start, end) {
+    build(start, end) {
         if (start === end)
             return new SegmentTreeNode(start, end, this._values[start]);
-        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);
+        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);
         cur.left = left;
         cur.right = right;
         return cur;
-    };
+    }
     /**
      * The function updates the value of a node in a segment tree and recalculates the sum of its children if they exist.
      * @param {number} index - The index parameter represents the index of the node in the segment tree that needs to be
@@ -163,18 +122,18 @@ var SegmentTree = /** @class */ (function () {
      * cur.val = val;` and pass a value for `val` in the
      * @returns The function does not return anything.
      */
-    SegmentTree.prototype.updateNode = function (index, sum, val) {
-        var root = this.root || null;
+    updateNode(index, sum, val) {
+        const root = this.root || null;
         if (!root) {
             return;
         }
-        var dfs = function (cur, index, sum, val) {
+        const dfs = (cur, index, sum, val) => {
             if (cur.start === cur.end && cur.start === index) {
                 cur.sum = sum;
                 // cur.val = val;
                 return;
             }
-            var mid = cur.start + Math.floor((cur.end - cur.start) / 2);
+            const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
             if (index <= mid) {
                 if (cur.left) {
                     dfs(cur.left, index, sum, val);
@@ -190,7 +149,7 @@ var SegmentTree = /** @class */ (function () {
             }
         };
         dfs(root, index, sum);
-    };
+    }
     /**
      * The function `querySumByRange` calculates the sum of values within a given range in a segment tree.
      * @param {number} indexA - The starting index of the range for which you want to calculate the sum.
@@ -198,16 +157,16 @@ var SegmentTree = /** @class */ (function () {
      * calculate the sum.
      * @returns The function `querySumByRange` returns a number.
      */
-    SegmentTree.prototype.querySumByRange = function (indexA, indexB) {
-        var root = this.root || null;
+    querySumByRange(indexA, indexB) {
+        const root = this.root || null;
         if (!root) {
             return 0;
         }
-        var dfs = function (cur, i, j) {
+        const dfs = (cur, i, j) => {
             if (cur.start === i && cur.end === j) {
                 return cur.sum;
             }
-            var mid = cur.start + Math.floor((cur.end - cur.start) / 2);
+            const 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) {
@@ -238,19 +197,18 @@ var SegmentTree = /** @class */ (function () {
             }
         };
         return dfs(root, indexA, indexB);
-    };
-    SegmentTree.prototype._setValues = function (value) {
+    }
+    _setValues(value) {
         this._values = value;
-    };
-    SegmentTree.prototype._setStart = function (value) {
+    }
+    _setStart(value) {
         this._start = value;
-    };
-    SegmentTree.prototype._setEnd = function (value) {
+    }
+    _setEnd(value) {
         this._end = value;
-    };
-    SegmentTree.prototype._setRoot = function (v) {
+    }
+    _setRoot(v) {
         this._root = v;
-    };
-    return SegmentTree;
-}());
+    }
+}
 exports.SegmentTree = SegmentTree;

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

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