data-structure-typed 1.19.3 → 1.19.5

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

@@ -1,30 +1,4 @@
 "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 __());
-    };
-})();
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AVLTree = exports.AVLTreeNode = void 0;
 /**
@@ -34,25 +8,19 @@ exports.AVLTree = exports.AVLTreeNode = void 0;
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-var bst_1 = require("./bst");
-var AVLTreeNode = /** @class */ (function (_super) {
-    __extends(AVLTreeNode, _super);
-    function AVLTreeNode() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return AVLTreeNode;
-}(bst_1.BSTNode));
+const bst_1 = require("./bst");
+class AVLTreeNode extends bst_1.BSTNode {
+}
 exports.AVLTreeNode = AVLTreeNode;
-var AVLTree = /** @class */ (function (_super) {
-    __extends(AVLTree, _super);
+class AVLTree extends bst_1.BST {
     /**
      * This is a constructor function for an AVL tree data structure in TypeScript.
      * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
      * constructor of the AVLTree class. It allows you to customize the behavior of the AVL tree by providing different
      * options.
      */
-    function AVLTree(options) {
-        return _super.call(this, options) || this;
+    constructor(options) {
+        super(options);
     }
     /**
      * The function creates a new AVL tree node with the given id and value.
@@ -62,9 +30,9 @@ var AVLTree = /** @class */ (function (_super) {
      * that will be stored in the node.
      * @returns a new AVLTreeNode object with the specified id and value.
      */
-    AVLTree.prototype.createNode = function (id, val) {
+    createNode(id, val) {
         return new AVLTreeNode(id, val);
-    };
+    }
     /**
      * The function overrides the add method of a binary tree node and balances the tree after inserting a new node.
      * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that we want to add.
@@ -72,12 +40,12 @@ var AVLTree = /** @class */ (function (_super) {
      * `N['val']`, which means it should be of the same type as the `val` property of the nodes in the binary tree.
      * @returns The method is returning the inserted node, or null or undefined if the insertion was not successful.
      */
-    AVLTree.prototype.add = function (id, val) {
-        var inserted = _super.prototype.add.call(this, id, val);
+    add(id, val) {
+        const inserted = super.add(id, val);
         if (inserted)
             this.balancePath(inserted);
         return inserted;
-    };
+    }
     /**
      * The function overrides the remove method of the Binary Search Tree class, performs the removal operation, and
      * then balances the tree if necessary.
@@ -88,66 +56,55 @@ var AVLTree = /** @class */ (function (_super) {
      * `isUpdateAllLeftSum` is set to `true`, the left sum of all nodes will be recalculated.
      * @returns The method is returning an array of `AVLTreeDeleted<N>` objects.
      */
-    AVLTree.prototype.remove = function (id, isUpdateAllLeftSum) {
-        var e_1, _a;
-        var deletedResults = _super.prototype.remove.call(this, id, isUpdateAllLeftSum);
-        try {
-            for (var deletedResults_1 = __values(deletedResults), deletedResults_1_1 = deletedResults_1.next(); !deletedResults_1_1.done; deletedResults_1_1 = deletedResults_1.next()) {
-                var needBalanced = deletedResults_1_1.value.needBalanced;
-                if (needBalanced) {
-                    this.balancePath(needBalanced);
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (deletedResults_1_1 && !deletedResults_1_1.done && (_a = deletedResults_1.return)) _a.call(deletedResults_1);
+    remove(id, isUpdateAllLeftSum) {
+        const deletedResults = super.remove(id, isUpdateAllLeftSum);
+        for (const { needBalanced } of deletedResults) {
+            if (needBalanced) {
+                this.balancePath(needBalanced);
             }
-            finally { if (e_1) throw e_1.error; }
         }
         return deletedResults;
-    };
+    }
     /**
      * The balance factor of a given AVL tree node is calculated by subtracting the height of its left subtree from the
      * height of its right subtree.
      * @param node - The parameter "node" is of type N, which represents a node in an AVL tree.
      * @returns The balance factor of the given AVL tree node.
      */
-    AVLTree.prototype.balanceFactor = function (node) {
+    balanceFactor(node) {
         if (!node.right) // node has no right subtree
             return -node.height;
         else if (!node.left) // node has no left subtree
             return +node.height;
         else
             return node.right.height - node.left.height;
-    };
+    }
     /**
      * The function updates the height of a node in an AVL tree based on the heights of its left and right subtrees.
      * @param node - The parameter `node` is an AVLTreeNode object, which represents a node in an AVL tree.
      */
-    AVLTree.prototype.updateHeight = function (node) {
+    updateHeight(node) {
         if (!node.left && !node.right) // node is a leaf
             node.height = 0;
         else if (!node.left) {
             // node has no left subtree
-            var rightHeight = node.right ? node.right.height : 0;
+            const rightHeight = node.right ? node.right.height : 0;
             node.height = 1 + rightHeight;
         }
         else if (!node.right) // node has no right subtree
             node.height = 1 + node.left.height;
         else
             node.height = 1 + Math.max(node.right.height, node.left.height);
-    };
+    }
     /**
      * The `balancePath` function balances the AVL tree by performing appropriate rotations based on the balance factor of
      * each node in the path from the given node to the root.
      * @param node - The `node` parameter is an AVLTreeNode object, which represents a node in an AVL tree.
      */
-    AVLTree.prototype.balancePath = function (node) {
-        var path = this.getPathToRoot(node);
-        for (var i = path.length - 1; i >= 0; i--) {
-            var A = path[i];
+    balancePath(node) {
+        const path = this.getPathToRoot(node);
+        for (let i = path.length - 1; i >= 0; i--) {
+            const A = path[i];
             this.updateHeight(A);
             switch (this.balanceFactor(A)) {
                 case -2:
@@ -171,14 +128,14 @@ var AVLTree = /** @class */ (function (_super) {
                     }
             }
         }
-    };
+    }
     /**
      * The `balanceLL` function performs a left-left rotation on an AVL tree to balance it.
      * @param A - The parameter A is an AVLTreeNode object.
      */
-    AVLTree.prototype.balanceLL = function (A) {
-        var parentOfA = A.parent;
-        var B = A.left; // A is left-heavy and B is left-heavy
+    balanceLL(A) {
+        const parentOfA = A.parent;
+        const B = A.left; // A is left-heavy and B is left-heavy
         A.parent = B;
         if (B && B.right) {
             B.right.parent = A;
@@ -205,15 +162,15 @@ var AVLTree = /** @class */ (function (_super) {
         this.updateHeight(A);
         if (B)
             this.updateHeight(B);
-    };
+    }
     /**
      * The `balanceLR` function performs a left-right rotation to balance an AVL tree.
      * @param A - A is an AVLTreeNode object.
      */
-    AVLTree.prototype.balanceLR = function (A) {
-        var parentOfA = A.parent;
-        var B = A.left; // A is left-heavy
-        var C = null;
+    balanceLR(A) {
+        const parentOfA = A.parent;
+        const B = A.left; // A is left-heavy
+        let C = null;
         if (B) {
             C = B.right; // B is right-heavy
         }
@@ -254,14 +211,14 @@ var AVLTree = /** @class */ (function (_super) {
         this.updateHeight(A); // Adjust heights
         B && this.updateHeight(B);
         C && this.updateHeight(C);
-    };
+    }
     /**
      * The `balanceRR` function performs a right-right rotation on an AVL tree to balance it.
      * @param A - The parameter A is an AVLTreeNode object.
      */
-    AVLTree.prototype.balanceRR = function (A) {
-        var parentOfA = A.parent;
-        var B = A.right; // A is right-heavy and B is right-heavy
+    balanceRR(A) {
+        const parentOfA = A.parent;
+        const B = A.right; // A is right-heavy and B is right-heavy
         A.parent = B;
         if (B) {
             if (B.left) {
@@ -289,15 +246,15 @@ var AVLTree = /** @class */ (function (_super) {
         }
         this.updateHeight(A);
         B && this.updateHeight(B);
-    };
+    }
     /**
      * The `balanceRL` function performs a right-left rotation to balance an AVL tree.
      * @param A - A is an AVLTreeNode object.
      */
-    AVLTree.prototype.balanceRL = function (A) {
-        var parentOfA = A.parent;
-        var B = A.right; // A is right-heavy
-        var C = null;
+    balanceRL(A) {
+        const parentOfA = A.parent;
+        const B = A.right; // A is right-heavy
+        let C = null;
         if (B) {
             C = B.left; // B is left-heavy
         }
@@ -338,7 +295,6 @@ var AVLTree = /** @class */ (function (_super) {
         this.updateHeight(A); // Adjust heights
         B && this.updateHeight(B);
         C && this.updateHeight(C);
-    };
-    return AVLTree;
-}(bst_1.BST));
+    }
+}
 exports.AVLTree = AVLTree;

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

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

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

@@ -8,26 +8,22 @@ exports.BinaryIndexedTree = void 0;
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-var BinaryIndexedTree = /** @class */ (function () {
+class BinaryIndexedTree {
     /**
      * The constructor initializes an array with a specified length and fills it with zeros.
      * @param {number} n - The parameter `n` represents the size of the array that will be used to store the sum tree. The
      * sum tree is a binary tree data structure used to efficiently calculate the sum of a range of elements in an array.
      * The size of the sum tree array is `n + 1` because
      */
-    function BinaryIndexedTree(n) {
+    constructor(n) {
         this._sumTree = new Array(n + 1).fill(0);
     }
-    Object.defineProperty(BinaryIndexedTree.prototype, "sumTree", {
-        get: function () {
-            return this._sumTree;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    BinaryIndexedTree.lowBit = function (x) {
+    get sumTree() {
+        return this._sumTree;
+    }
+    static lowBit(x) {
         return x & (-x);
-    };
+    }
     /**
      * The update function updates the values in a binary indexed tree by adding a delta value to the specified index and
      * its ancestors.
@@ -36,12 +32,12 @@ var BinaryIndexedTree = /** @class */ (function () {
      * @param {number} delta - The "delta" parameter represents the change in value that needs to be added to the element
      * at index "i" in the "_sumTree" array.
      */
-    BinaryIndexedTree.prototype.update = function (i, delta) {
+    update(i, delta) {
         while (i < this._sumTree.length) {
             this._sumTree[i] += delta;
             i += BinaryIndexedTree.lowBit(i);
         }
-    };
+    }
     /**
      * The function calculates the prefix sum of an array using a binary indexed tree.
      * @param {number} i - The parameter "i" in the function "getPrefixSum" represents the index of the element in the
@@ -49,14 +45,14 @@ var BinaryIndexedTree = /** @class */ (function () {
      * @returns The function `getPrefixSum` returns the prefix sum of the elements in the binary indexed tree up to index
      * `i`.
      */
-    BinaryIndexedTree.prototype.getPrefixSum = function (i) {
-        var sum = 0;
+    getPrefixSum(i) {
+        let sum = 0;
         while (i > 0) {
             sum += this._sumTree[i];
             i -= BinaryIndexedTree.lowBit(i);
         }
         return sum;
-    };
+    }
     /**
      * The function `getRangeSum` calculates the sum of a range of numbers in an array.
      * @param {number} start - The start parameter is the starting index of the range for which we want to calculate the
@@ -65,14 +61,13 @@ var BinaryIndexedTree = /** @class */ (function () {
      * the sum.
      * @returns the sum of the elements in the range specified by the start and end indices.
      */
-    BinaryIndexedTree.prototype.getRangeSum = function (start, end) {
+    getRangeSum(start, end) {
         if (!(0 <= start && start <= end && end <= this._sumTree.length))
             throw 'Index out of bounds';
         return this.getPrefixSum(end) - this.getPrefixSum(start);
-    };
-    BinaryIndexedTree.prototype._setSumTree = function (value) {
+    }
+    _setSumTree(value) {
         this._sumTree = value;
-    };
-    return BinaryIndexedTree;
-}());
+    }
+}
 exports.BinaryIndexedTree = BinaryIndexedTree;

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

@@ -6,42 +6,21 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-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.BinaryTree = exports.BinaryTreeNode = void 0;
-var abstract_binary_tree_1 = require("./abstract-binary-tree");
-var BinaryTreeNode = /** @class */ (function (_super) {
-    __extends(BinaryTreeNode, _super);
-    function BinaryTreeNode() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return BinaryTreeNode;
-}(abstract_binary_tree_1.AbstractBinaryTreeNode));
+const abstract_binary_tree_1 = require("./abstract-binary-tree");
+class BinaryTreeNode extends abstract_binary_tree_1.AbstractBinaryTreeNode {
+}
 exports.BinaryTreeNode = BinaryTreeNode;
-var BinaryTree = /** @class */ (function (_super) {
-    __extends(BinaryTree, _super);
+class BinaryTree extends abstract_binary_tree_1.AbstractBinaryTree {
     /**
      * This is a constructor function for a binary tree class that takes an optional options parameter.
      * @param {BinaryTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
      * constructor of the `BinaryTree` class. It allows you to customize the behavior of the binary tree by providing
      * different configuration options.
      */
-    function BinaryTree(options) {
-        return _super.call(this, options) || this;
+    constructor(options) {
+        super(options);
     }
     /**
      * The function creates a new binary tree node with an optional value.
@@ -51,9 +30,8 @@ var BinaryTree = /** @class */ (function (_super) {
      * stored in the node.
      * @returns a new instance of a BinaryTreeNode with the specified id and value.
      */
-    BinaryTree.prototype.createNode = function (id, val) {
+    createNode(id, val) {
         return new BinaryTreeNode(id, val);
-    };
-    return BinaryTree;
-}(abstract_binary_tree_1.AbstractBinaryTree));
+    }
+}
 exports.BinaryTree = BinaryTree;