data-structure-typed 1.19.3 → 1.19.4

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

@@ -1,63 +1,25 @@
 "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 __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BST = exports.BSTNode = void 0;
-var types_1 = require("../types");
-var binary_tree_1 = require("./binary-tree");
-var BSTNode = /** @class */ (function (_super) {
-    __extends(BSTNode, _super);
-    function BSTNode() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return BSTNode;
-}(binary_tree_1.BinaryTreeNode));
+const types_1 = require("../types");
+const binary_tree_1 = require("./binary-tree");
+class BSTNode extends binary_tree_1.BinaryTreeNode {
+}
 exports.BSTNode = BSTNode;
-var BST = /** @class */ (function (_super) {
-    __extends(BST, _super);
+class BST extends binary_tree_1.BinaryTree {
     /**
      * The constructor function initializes a binary search tree object with an optional comparator function.
      * @param {BSTOptions} [options] - An optional object that contains configuration options for the binary search tree.
      */
-    function BST(options) {
-        var _this = _super.call(this, options) || this;
-        _this._comparator = function (a, b) { return a - b; };
+    constructor(options) {
+        super(options);
+        this._comparator = (a, b) => a - b;
         if (options !== undefined) {
-            var comparator = options.comparator;
+            const { comparator } = options;
             if (comparator !== undefined) {
-                _this._comparator = comparator;
+                this._comparator = comparator;
             }
         }
-        return _this;
     }
     /**
      * The function creates a new binary search tree node with the given id and value.
@@ -67,9 +29,9 @@ var BST = /** @class */ (function (_super) {
      * that will be stored in the node.
      * @returns a new instance of the BSTNode class with the specified id and value.
      */
-    BST.prototype.createNode = function (id, val) {
+    createNode(id, val) {
         return new BSTNode(id, val);
-    };
+    }
     /**
      * The `add` function adds a new node to a binary tree, ensuring that duplicates are not accepted.
      * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that we want to add. It
@@ -79,17 +41,17 @@ var BST = /** @class */ (function (_super) {
      * @returns The function `add` returns the inserted node (`inserted`) if it was successfully added to the binary tree.
      * If the node was not added (e.g., due to a duplicate ID), it returns `null` or `undefined`.
      */
-    BST.prototype.add = function (id, val) {
-        var inserted = null;
-        var newNode = this.createNode(id, val);
+    add(id, val) {
+        let inserted = null;
+        const newNode = this.createNode(id, val);
         if (this.root === null) {
             this._setRoot(newNode);
             this._setSize(this.size + 1);
             inserted = (this.root);
         }
         else {
-            var cur = this.root;
-            var traversing = true;
+            let cur = this.root;
+            let traversing = true;
             while (traversing) {
                 if (cur !== null && newNode !== null) {
                     if (this._compare(cur.id, id) === types_1.CP.eq) {
@@ -143,7 +105,7 @@ var BST = /** @class */ (function (_super) {
             }
         }
         return inserted;
-    };
+    }
     /**
      * The function returns the first node in a binary tree that matches the given property name and value.
      * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
@@ -152,11 +114,11 @@ var BST = /** @class */ (function (_super) {
      * specifies the property name to use for searching the binary tree nodes. If not provided, it defaults to `'id'`.
      * @returns The method is returning either a BinaryTreeNodeId or N (generic type) or null.
      */
-    BST.prototype.get = function (nodeProperty, propertyName) {
+    get(nodeProperty, propertyName) {
         var _a;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         return (_a = this.getNodes(nodeProperty, propertyName, true)[0]) !== null && _a !== void 0 ? _a : null;
-    };
+    }
     /**
      * The function returns the id of the rightmost node if the comparison between two values is less than, the id of the
      * leftmost node if the comparison is greater than, and the id of the rightmost node otherwise.
@@ -164,7 +126,7 @@ var BST = /** @class */ (function (_super) {
      * the values at index 0 and 1 is less than, otherwise it returns the id of the leftmost node. If the comparison is
      * equal, it returns the id of the rightmost node. If there are no nodes in the tree, it returns 0.
      */
-    BST.prototype.lastKey = function () {
+    lastKey() {
         var _a, _b, _c, _d, _e, _f;
         if (this._compare(0, 1) === types_1.CP.lt)
             return (_b = (_a = this.getRightMost()) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : 0;
@@ -172,7 +134,7 @@ var BST = /** @class */ (function (_super) {
             return (_d = (_c = this.getLeftMost()) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : 0;
         else
             return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.id) !== null && _f !== void 0 ? _f : 0;
-    };
+    }
     /**
      * The function `getNodes` returns an array of nodes in a binary tree that match a given property value.
      * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or an
@@ -184,35 +146,34 @@ var BST = /** @class */ (function (_super) {
      * is set to `true`, the function will return an array with only one node (if
      * @returns an array of nodes (type N).
      */
-    BST.prototype.getNodes = function (nodeProperty, propertyName, onlyOne) {
-        var _this = this;
+    getNodes(nodeProperty, propertyName, onlyOne) {
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         if (!this.root)
             return [];
-        var result = [];
+        const result = [];
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_1 = function (cur) {
-                if (_this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
+            const _traverse = (cur) => {
+                if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                     return;
                 if (!cur.left && !cur.right)
                     return;
                 if (propertyName === 'id') {
-                    if (_this._compare(cur.id, nodeProperty) === types_1.CP.gt)
-                        cur.left && _traverse_1(cur.left);
-                    if (_this._compare(cur.id, nodeProperty) === types_1.CP.lt)
-                        cur.right && _traverse_1(cur.right);
+                    if (this._compare(cur.id, nodeProperty) === types_1.CP.gt)
+                        cur.left && _traverse(cur.left);
+                    if (this._compare(cur.id, nodeProperty) === types_1.CP.lt)
+                        cur.right && _traverse(cur.right);
                 }
                 else {
-                    cur.left && _traverse_1(cur.left);
-                    cur.right && _traverse_1(cur.right);
+                    cur.left && _traverse(cur.left);
+                    cur.right && _traverse(cur.right);
                 }
             };
-            _traverse_1(this.root);
+            _traverse(this.root);
         }
         else {
-            var queue = [this.root];
+            const queue = [this.root];
             while (queue.length > 0) {
-                var cur = queue.shift();
+                const cur = queue.shift();
                 if (cur) {
                     if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                         return result;
@@ -230,7 +191,7 @@ var BST = /** @class */ (function (_super) {
             }
         }
         return result;
-    };
+    }
     // --- start additional functions
     /**
      * The `lesserSum` function calculates the sum of property values in a binary tree for nodes that have a property value
@@ -241,8 +202,7 @@ var BST = /** @class */ (function (_super) {
      * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in the
      * binary tree that have a lesser value than the specified `beginNode` based on the `propertyName`.
      */
-    BST.prototype.lesserSum = function (beginNode, propertyName) {
-        var _this = this;
+    lesserSum(beginNode, propertyName) {
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         if (typeof beginNode === 'number')
             beginNode = this.get(beginNode, 'id');
@@ -250,9 +210,9 @@ var BST = /** @class */ (function (_super) {
             return 0;
         if (!this.root)
             return 0;
-        var id = beginNode.id;
-        var getSumByPropertyName = function (cur) {
-            var needSum;
+        const id = beginNode.id;
+        const getSumByPropertyName = (cur) => {
+            let needSum;
             switch (propertyName) {
                 case 'id':
                     needSum = cur.id;
@@ -263,39 +223,39 @@ var BST = /** @class */ (function (_super) {
             }
             return needSum;
         };
-        var sum = 0;
+        let sum = 0;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_2 = function (cur) {
-                var compared = _this._compare(cur.id, id);
+            const _traverse = (cur) => {
+                const compared = this._compare(cur.id, id);
                 if (compared === types_1.CP.eq) {
                     if (cur.right)
-                        sum += _this.subTreeSum(cur.right, propertyName);
+                        sum += this.subTreeSum(cur.right, propertyName);
                     return;
                 }
                 else if (compared === types_1.CP.lt) {
                     if (cur.left)
-                        sum += _this.subTreeSum(cur.left, propertyName);
+                        sum += this.subTreeSum(cur.left, propertyName);
                     sum += getSumByPropertyName(cur);
                     if (cur.right)
-                        _traverse_2(cur.right);
+                        _traverse(cur.right);
                     else
                         return;
                 }
                 else {
                     if (cur.left)
-                        _traverse_2(cur.left);
+                        _traverse(cur.left);
                     else
                         return;
                 }
             };
-            _traverse_2(this.root);
+            _traverse(this.root);
         }
         else {
-            var queue = [this.root];
+            const queue = [this.root];
             while (queue.length > 0) {
-                var cur = queue.shift();
+                const cur = queue.shift();
                 if (cur) {
-                    var compared = this._compare(cur.id, id);
+                    const compared = this._compare(cur.id, id);
                     if (compared === types_1.CP.eq) {
                         if (cur.right)
                             sum += this.subTreeSum(cur.right, propertyName);
@@ -320,7 +280,7 @@ var BST = /** @class */ (function (_super) {
             }
         }
         return sum;
-    };
+    }
     /**
      * The `allGreaterNodesAdd` function adds a delta value to the specified property of all nodes in a binary tree that
      * have a greater value than a given node.
@@ -333,17 +293,16 @@ var BST = /** @class */ (function (_super) {
      * 'id'.
      * @returns a boolean value.
      */
-    BST.prototype.allGreaterNodesAdd = function (node, delta, propertyName) {
-        var _this = this;
+    allGreaterNodesAdd(node, delta, propertyName) {
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         if (typeof node === 'number')
             node = this.get(node, 'id');
         if (!node)
             return false;
-        var id = node.id;
+        const id = node.id;
         if (!this.root)
             return false;
-        var _sumByPropertyName = function (cur) {
+        const _sumByPropertyName = (cur) => {
             switch (propertyName) {
                 case 'id':
                     cur.id += delta;
@@ -354,26 +313,26 @@ var BST = /** @class */ (function (_super) {
             }
         };
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_3 = function (cur) {
-                var compared = _this._compare(cur.id, id);
+            const _traverse = (cur) => {
+                const compared = this._compare(cur.id, id);
                 if (compared === types_1.CP.gt)
                     _sumByPropertyName(cur);
                 if (!cur.left && !cur.right)
                     return;
-                if (cur.left && _this._compare(cur.left.id, id) === types_1.CP.gt)
-                    _traverse_3(cur.left);
-                if (cur.right && _this._compare(cur.right.id, id) === types_1.CP.gt)
-                    _traverse_3(cur.right);
+                if (cur.left && this._compare(cur.left.id, id) === types_1.CP.gt)
+                    _traverse(cur.left);
+                if (cur.right && this._compare(cur.right.id, id) === types_1.CP.gt)
+                    _traverse(cur.right);
             };
-            _traverse_3(this.root);
+            _traverse(this.root);
             return true;
         }
         else {
-            var queue = [this.root];
+            const queue = [this.root];
             while (queue.length > 0) {
-                var cur = queue.shift();
+                const cur = queue.shift();
                 if (cur) {
-                    var compared = this._compare(cur.id, id);
+                    const compared = this._compare(cur.id, id);
                     if (compared === types_1.CP.gt)
                         _sumByPropertyName(cur);
                     if (cur.left && this._compare(cur.left.id, id) === types_1.CP.gt)
@@ -384,7 +343,7 @@ var BST = /** @class */ (function (_super) {
             }
             return true;
         }
-    };
+    }
     /**
      * Balancing Adjustment:
      * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.
@@ -399,34 +358,33 @@ var BST = /** @class */ (function (_super) {
      * constructs a balanced binary search tree using either a recursive or iterative approach.
      * @returns The function `perfectlyBalance()` returns a boolean value.
      */
-    BST.prototype.perfectlyBalance = function () {
-        var _this = this;
-        var sorted = this.DFS('in', 'node'), n = sorted.length;
+    perfectlyBalance() {
+        const sorted = this.DFS('in', 'node'), n = sorted.length;
         this.clear();
         if (sorted.length < 1)
             return false;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var buildBalanceBST_1 = function (l, r) {
+            const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
-                var m = l + Math.floor((r - l) / 2);
-                var midNode = sorted[m];
-                _this.add(midNode.id, midNode.val);
-                buildBalanceBST_1(l, m - 1);
-                buildBalanceBST_1(m + 1, r);
+                const m = l + Math.floor((r - l) / 2);
+                const midNode = sorted[m];
+                this.add(midNode.id, midNode.val);
+                buildBalanceBST(l, m - 1);
+                buildBalanceBST(m + 1, r);
             };
-            buildBalanceBST_1(0, n - 1);
+            buildBalanceBST(0, n - 1);
             return true;
         }
         else {
-            var stack = [[0, n - 1]];
+            const stack = [[0, n - 1]];
             while (stack.length > 0) {
-                var popped = stack.pop();
+                const popped = stack.pop();
                 if (popped) {
-                    var _a = __read(popped, 2), l = _a[0], r = _a[1];
+                    const [l, r] = popped;
                     if (l <= r) {
-                        var m = l + Math.floor((r - l) / 2);
-                        var midNode = sorted[m];
+                        const m = l + Math.floor((r - l) / 2);
+                        const midNode = sorted[m];
                         this.add(midNode.id, midNode.val);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
@@ -435,31 +393,31 @@ var BST = /** @class */ (function (_super) {
             }
             return true;
         }
-    };
+    }
     /**
      * The function `isAVLBalanced` checks if a binary tree is balanced according to the AVL tree property.
      * @returns a boolean value.
      */
-    BST.prototype.isAVLBalanced = function () {
+    isAVLBalanced() {
         var _a, _b;
         if (!this.root)
             return true;
-        var balanced = true;
+        let balanced = true;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _height_1 = function (cur) {
+            const _height = (cur) => {
                 if (!cur)
                     return 0;
-                var leftHeight = _height_1(cur.left), rightHeight = _height_1(cur.right);
+                const leftHeight = _height(cur.left), rightHeight = _height(cur.right);
                 if (Math.abs(leftHeight - rightHeight) > 1)
                     balanced = false;
                 return Math.max(leftHeight, rightHeight) + 1;
             };
-            _height_1(this.root);
+            _height(this.root);
         }
         else {
-            var stack = [];
-            var node = this.root, last = null;
-            var depths = new Map();
+            const stack = [];
+            let node = this.root, last = null;
+            const depths = new Map();
             while (stack.length > 0 || node) {
                 if (node) {
                     stack.push(node);
@@ -470,8 +428,8 @@ var BST = /** @class */ (function (_super) {
                     if (!node.right || last === node.right) {
                         node = stack.pop();
                         if (node) {
-                            var left = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
-                            var right = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
+                            const left = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
+                            const right = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
                             if (Math.abs(left - right) > 1)
                                 return false;
                             depths.set(node, 1 + Math.max(left, right));
@@ -485,7 +443,7 @@ var BST = /** @class */ (function (_super) {
             }
         }
         return balanced;
-    };
+    }
     /**
      * The function compares two binary tree node IDs using a comparator function and returns whether the first ID is
      * greater than, less than, or equal to the second ID.
@@ -494,15 +452,14 @@ var BST = /** @class */ (function (_super) {
      * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater than), CP.lt (less
      * than), or CP.eq (equal).
      */
-    BST.prototype._compare = function (a, b) {
-        var compared = this._comparator(a, b);
+    _compare(a, b) {
+        const compared = this._comparator(a, b);
         if (compared > 0)
             return types_1.CP.gt;
         else if (compared < 0)
             return types_1.CP.lt;
         else
             return types_1.CP.eq;
-    };
-    return BST;
-}(binary_tree_1.BinaryTree));
+    }
+}
 exports.BST = BST;

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

@@ -1,69 +1,45 @@
 "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.RBTree = exports.RBTreeNode = void 0;
-var types_1 = require("../types");
-var bst_1 = require("./bst");
-var RBTreeNode = /** @class */ (function (_super) {
-    __extends(RBTreeNode, _super);
-    function RBTreeNode(id, color, val) {
-        var _this = _super.call(this, id, val) || this;
-        _this._color = types_1.RBColor.RED;
-        _this._color = color;
-        return _this;
+const types_1 = require("../types");
+const bst_1 = require("./bst");
+class RBTreeNode extends bst_1.BSTNode {
+    constructor(id, color, val) {
+        super(id, val);
+        this._color = types_1.RBColor.RED;
+        this._color = color;
     }
-    Object.defineProperty(RBTreeNode.prototype, "color", {
-        get: function () {
-            return this._color;
-        },
-        set: function (value) {
-            this._color = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return RBTreeNode;
-}(bst_1.BSTNode));
+    get color() {
+        return this._color;
+    }
+    set color(value) {
+        this._color = value;
+    }
+}
 exports.RBTreeNode = RBTreeNode;
-var RBTree = /** @class */ (function (_super) {
-    __extends(RBTree, _super);
-    function RBTree(options) {
-        return _super.call(this, options) || this;
+class RBTree extends bst_1.BST {
+    constructor(options) {
+        super(options);
     }
-    RBTree.prototype.createNode = function (id, val) {
+    createNode(id, val) {
         return new RBTreeNode(id, types_1.RBColor.RED, val);
-    };
+    }
     // private override _root: BinaryTreeNode<N> | null = null;
     //
     // override get root(): BinaryTreeNode<N> | null {
     //     return this._root;
     // }
-    RBTree.prototype.insert = function (id, val) {
-    };
-    RBTree.prototype.leftRotate = function (node) {
-    };
-    RBTree.prototype.rightRotate = function (node) {
-    };
-    RBTree.prototype.insertFixup = function (node) {
-    };
-    RBTree.prototype.deleteFixup = function (node) {
-    };
-    RBTree.prototype.transplant = function (u, v) {
-    };
-    return RBTree;
-}(bst_1.BST));
+    insert(id, val) {
+    }
+    leftRotate(node) {
+    }
+    rightRotate(node) {
+    }
+    insertFixup(node) {
+    }
+    deleteFixup(node) {
+    }
+    transplant(u, v) {
+    }
+}
 exports.RBTree = RBTree;