data-structure-typed 1.34.7 → 1.34.9

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

@@ -1,8 +1,8 @@
 import { CP, LoopType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 export class BSTNode extends BinaryTreeNode {
-    constructor(id, val) {
-        super(id, val);
+    constructor(key, val) {
+        super(key, val);
     }
 }
 export class BST extends BinaryTree {
@@ -21,36 +21,36 @@ export class BST extends BinaryTree {
         }
     }
     /**
-     * The function creates a new binary search tree node with the given id and value.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
+     * The function creates a new binary search tree node with the given key and value.
+     * @param {BinaryTreeNodeKey} key - The `key` parameter is the identifier for the binary tree node. It is used to uniquely
      * identify each node in the binary tree.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the value
      * that will be stored in the node.
-     * @returns a new instance of the BSTNode class with the specified id and value.
+     * @returns a new instance of the BSTNode class with the specified key and value.
      */
-    createNode(id, val) {
-        return new BSTNode(id, val);
+    createNode(key, val) {
+        return new BSTNode(key, val);
     }
     /**
      * The `add` function adds a new node to a binary search tree, either by creating a new node or by updating an existing
      * node with the same ID.
-     * @param {BinaryTreeNodeId | N | null} idOrNode - The `idOrNode` parameter can be either a `BinaryTreeNodeId` or a `N`
+     * @param {BinaryTreeNodeKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a `BinaryTreeNodeKey` or a `N`
      * (which represents a binary tree node) or `null`.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the `val` property of the new node
      * being added to the binary search tree.
      * @returns The function `add` returns the inserted node (`inserted`) which can be of type `N`, `null`, or `undefined`.
      */
-    add(idOrNode, val) {
+    add(keyOrNode, val) {
         // TODO support node as a param
         let inserted = null;
         let newNode = null;
-        if (idOrNode instanceof BSTNode) {
-            newNode = idOrNode;
+        if (keyOrNode instanceof BSTNode) {
+            newNode = keyOrNode;
         }
-        else if (typeof idOrNode === 'number') {
-            newNode = this.createNode(idOrNode, val);
+        else if (typeof keyOrNode === 'number') {
+            newNode = this.createNode(keyOrNode, val);
         }
-        else if (idOrNode === null) {
+        else if (keyOrNode === null) {
             newNode = null;
         }
         if (this.root === null) {
@@ -63,7 +63,7 @@ export class BST extends BinaryTree {
             let traversing = true;
             while (traversing) {
                 if (cur !== null && newNode !== null) {
-                    if (this._compare(cur.id, newNode.id) === CP.eq) {
+                    if (this._compare(cur.key, newNode.key) === CP.eq) {
                         if (newNode) {
                             cur.val = newNode.val;
                         }
@@ -71,7 +71,7 @@ export class BST extends BinaryTree {
                         traversing = false;
                         inserted = cur;
                     }
-                    else if (this._compare(cur.id, newNode.id) === CP.gt) {
+                    else if (this._compare(cur.key, newNode.key) === CP.gt) {
                         // Traverse left of the node
                         if (cur.left === undefined) {
                             if (newNode) {
@@ -89,7 +89,7 @@ export class BST extends BinaryTree {
                                 cur = cur.left;
                         }
                     }
-                    else if (this._compare(cur.id, newNode.id) === CP.lt) {
+                    else if (this._compare(cur.key, newNode.key) === CP.lt) {
                         // Traverse right of the node
                         if (cur.right === undefined) {
                             if (newNode) {
@@ -118,46 +118,46 @@ export class BST extends BinaryTree {
     /**
      * The `addMany` function overrides the base class method to add multiple nodes to a binary search tree in a balanced
      * manner.
-     * @param {[BinaryTreeNodeId | N , N['val']][]} idsOrNodes - The `idsOrNodes` parameter in the `addMany` function is an array of
-     * `BinaryTreeNodeId` or `N` (node) objects, or `null` values. It represents the nodes or node IDs that need to be added
+     * @param {[BinaryTreeNodeKey | N , N['val']][]} keysOrNodes - The `keysOrNodes` parameter in the `addMany` function is an array of
+     * `BinaryTreeNodeKey` or `N` (node) objects, or `null` values. It represents the nodes or node IDs that need to be added
      * to the binary search tree.
      * @param {N['val'][]} data - The values of tree nodes
      * @param {boolean} isBalanceAdd - If true the nodes will be balance inserted in binary search method.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(idsOrNodes, data, isBalanceAdd = false) {
+    addMany(keysOrNodes, data, isBalanceAdd = false) {
         function hasNoNull(arr) {
             return arr.indexOf(null) === -1;
         }
-        if (!isBalanceAdd || !hasNoNull(idsOrNodes)) {
-            return super.addMany(idsOrNodes, data);
+        if (!isBalanceAdd || !hasNoNull(keysOrNodes)) {
+            return super.addMany(keysOrNodes, data);
         }
         const inserted = [];
-        const combinedArr = idsOrNodes.map((value, index) => [value, data === null || data === void 0 ? void 0 : data[index]]);
+        const combinedArr = keysOrNodes.map((value, index) => [value, data === null || data === void 0 ? void 0 : data[index]]);
         let sorted = [];
         function isNodeOrNullTuple(arr) {
-            for (const [idOrNode] of arr)
-                if (idOrNode instanceof BSTNode)
+            for (const [keyOrNode] of arr)
+                if (keyOrNode instanceof BSTNode)
                     return true;
             return false;
         }
-        function isBinaryTreeIdOrNullTuple(arr) {
-            for (const [idOrNode] of arr)
-                if (typeof idOrNode === 'number')
+        function isBinaryTreeKeyOrNullTuple(arr) {
+            for (const [keyOrNode] of arr)
+                if (typeof keyOrNode === 'number')
                     return true;
             return false;
         }
-        let sortedIdsOrNodes = [], sortedData = [];
+        let sortedKeysOrNodes = [], sortedData = [];
         if (isNodeOrNullTuple(combinedArr)) {
-            sorted = combinedArr.sort((a, b) => a[0].id - b[0].id);
+            sorted = combinedArr.sort((a, b) => a[0].key - b[0].key);
         }
-        else if (isBinaryTreeIdOrNullTuple(combinedArr)) {
+        else if (isBinaryTreeKeyOrNullTuple(combinedArr)) {
             sorted = combinedArr.sort((a, b) => a[0] - b[0]);
         }
         else {
-            throw new Error('Invalid input idsOrNodes');
+            throw new Error('Invalid input keysOrNodes');
         }
-        sortedIdsOrNodes = sorted.map(([idOrNode]) => idOrNode);
+        sortedKeysOrNodes = sorted.map(([keyOrNode]) => keyOrNode);
         sortedData = sorted.map(([, val]) => val);
         const recursive = (arr, data) => {
             if (arr.length === 0)
@@ -177,7 +177,7 @@ export class BST extends BinaryTree {
                     const [l, r] = popped;
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
-                        const newNode = this.add(sortedIdsOrNodes[m], sortedData === null || sortedData === void 0 ? void 0 : sortedData[m]);
+                        const newNode = this.add(sortedKeysOrNodes[m], sortedData === null || sortedData === void 0 ? void 0 : sortedData[m]);
                         inserted.push(newNode);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
@@ -186,7 +186,7 @@ export class BST extends BinaryTree {
             }
         };
         if (this.loopType === LoopType.RECURSIVE) {
-            recursive(sortedIdsOrNodes, sortedData);
+            recursive(sortedKeysOrNodes, sortedData);
         }
         else {
             iterative();
@@ -195,45 +195,44 @@ export class BST extends BinaryTree {
     }
     /**
      * 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
+     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or a
      * generic type `N`. It represents the property of the binary tree node that you want to search for.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * 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.
+     * specifies the property name to use for searching the binary tree nodes. If not provided, it defaults to `'key'`.
+     * @returns The method is returning either a BinaryTreeNodeKey or N (generic type) or null.
      */
-    get(nodeProperty, propertyName) {
+    get(nodeProperty, propertyName = 'key') {
         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.
-     * @returns The method `lastKey()` returns the id of the rightmost node in the binary tree if the comparison between
-     * 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.
+     * The function returns the key of the rightmost node if the comparison between two values is less than, the key of the
+     * leftmost node if the comparison is greater than, and the key of the rightmost node otherwise.
+     * @returns The method `lastKey()` returns the key of the rightmost node in the binary tree if the comparison between
+     * the values at index 0 and 1 is less than, otherwise it returns the key of the leftmost node. If the comparison is
+     * equal, it returns the key of the rightmost node. If there are no nodes in the tree, it returns 0.
      */
     lastKey() {
         var _a, _b, _c, _d, _e, _f;
         if (this._compare(0, 1) === CP.lt)
-            return (_b = (_a = this.getRightMost()) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : 0;
+            return (_b = (_a = this.getRightMost()) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : 0;
         else if (this._compare(0, 1) === CP.gt)
-            return (_d = (_c = this.getLeftMost()) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : 0;
+            return (_d = (_c = this.getLeftMost()) === null || _c === void 0 ? void 0 : _c.key) !== 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;
+            return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.key) !== 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
+     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or an
      * `N` type. It represents the property of the binary tree node that you want to compare with.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property name to use for comparison. If not provided, it defaults to `'id'`.
+     * specifies the property name to use for comparison. If not provided, it defaults to `'key'`.
      * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
      * return only one node that matches the given `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne`
      * is set to `true`, the function will return an array with only one node (if
      * @returns an array of nodes (type N).
      */
-    getNodes(nodeProperty, propertyName = 'id', onlyOne) {
+    getNodes(nodeProperty, propertyName = 'key', onlyOne = false) {
         if (!this.root)
             return [];
         const result = [];
@@ -243,10 +242,10 @@ export class BST extends BinaryTree {
                     return;
                 if (!cur.left && !cur.right)
                     return;
-                if (propertyName === 'id') {
-                    if (this._compare(cur.id, nodeProperty) === CP.gt)
+                if (propertyName === 'key') {
+                    if (this._compare(cur.key, nodeProperty) === CP.gt)
                         cur.left && _traverse(cur.left);
-                    if (this._compare(cur.id, nodeProperty) === CP.lt)
+                    if (this._compare(cur.key, nodeProperty) === CP.lt)
                         cur.right && _traverse(cur.right);
                 }
                 else {
@@ -263,10 +262,10 @@ export class BST extends BinaryTree {
                 if (cur) {
                     if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                         return result;
-                    if (propertyName === 'id') {
-                        if (this._compare(cur.id, nodeProperty) === CP.gt)
+                    if (propertyName === 'key') {
+                        if (this._compare(cur.key, nodeProperty) === CP.gt)
                             cur.left && queue.push(cur.left);
-                        if (this._compare(cur.id, nodeProperty) === CP.lt)
+                        if (this._compare(cur.key, nodeProperty) === CP.lt)
                             cur.right && queue.push(cur.right);
                     }
                     else {
@@ -282,29 +281,28 @@ export class BST extends BinaryTree {
     /**
      * The `lesserSum` function calculates the sum of property values in a binary tree for nodes that have a property value
      * less than a given node.
-     * @param {N | BinaryTreeNodeId | null} beginNode - The `beginNode` parameter can be one of the following:
+     * @param {N | BinaryTreeNodeKey | null} beginNode - The `beginNode` parameter can be one of the following:
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property name to use for calculating the sum. If not provided, it defaults to `'id'`.
+     * specifies the property name to use for calculating the sum. If not provided, it defaults to `'key'`.
      * @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`.
      */
-    lesserSum(beginNode, propertyName) {
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+    lesserSum(beginNode, propertyName = 'key') {
         if (typeof beginNode === 'number')
-            beginNode = this.get(beginNode, 'id');
+            beginNode = this.get(beginNode, 'key');
         if (!beginNode)
             return 0;
         if (!this.root)
             return 0;
-        const id = beginNode.id;
+        const key = beginNode.key;
         const getSumByPropertyName = (cur) => {
             let needSum;
             switch (propertyName) {
-                case 'id':
-                    needSum = cur.id;
+                case 'key':
+                    needSum = cur.key;
                     break;
                 default:
-                    needSum = cur.id;
+                    needSum = cur.key;
                     break;
             }
             return needSum;
@@ -312,7 +310,7 @@ export class BST extends BinaryTree {
         let sum = 0;
         if (this.loopType === LoopType.RECURSIVE) {
             const _traverse = (cur) => {
-                const compared = this._compare(cur.id, id);
+                const compared = this._compare(cur.key, key);
                 if (compared === CP.eq) {
                     if (cur.right)
                         sum += this.subTreeSum(cur.right, propertyName);
@@ -341,7 +339,7 @@ export class BST extends BinaryTree {
             while (queue.length > 0) {
                 const cur = queue.shift();
                 if (cur) {
-                    const compared = this._compare(cur.id, id);
+                    const compared = this._compare(cur.key, key);
                     if (compared === CP.eq) {
                         if (cur.right)
                             sum += this.subTreeSum(cur.right, propertyName);
@@ -371,44 +369,43 @@ export class BST extends BinaryTree {
     /**
      * 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.
-     * @param {N | BinaryTreeNodeId | null} node - The `node` parameter can be either of type `N` (a generic type),
-     * `BinaryTreeNodeId`, or `null`. It represents the node in the binary tree to which the delta value will be added.
+     * @param {N | BinaryTreeNodeKey | null} node - The `node` parameter can be either of type `N` (a generic type),
+     * `BinaryTreeNodeKey`, or `null`. It represents the node in the binary tree to which the delta value will be added.
      * @param {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
      * each greater node should be increased.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property name of the nodes in the binary tree that you want to update. If not provided, it defaults to
-     * 'id'.
+     * 'key'.
      * @returns a boolean value.
      */
-    allGreaterNodesAdd(node, delta, propertyName) {
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+    allGreaterNodesAdd(node, delta, propertyName = 'key') {
         if (typeof node === 'number')
-            node = this.get(node, 'id');
+            node = this.get(node, 'key');
         if (!node)
             return false;
-        const id = node.id;
+        const key = node.key;
         if (!this.root)
             return false;
         const _sumByPropertyName = (cur) => {
             switch (propertyName) {
-                case 'id':
-                    cur.id += delta;
+                case 'key':
+                    cur.key += delta;
                     break;
                 default:
-                    cur.id += delta;
+                    cur.key += delta;
                     break;
             }
         };
         if (this.loopType === LoopType.RECURSIVE) {
             const _traverse = (cur) => {
-                const compared = this._compare(cur.id, id);
+                const compared = this._compare(cur.key, key);
                 if (compared === CP.gt)
                     _sumByPropertyName(cur);
                 if (!cur.left && !cur.right)
                     return;
-                if (cur.left && this._compare(cur.left.id, id) === CP.gt)
+                if (cur.left && this._compare(cur.left.key, key) === CP.gt)
                     _traverse(cur.left);
-                if (cur.right && this._compare(cur.right.id, id) === CP.gt)
+                if (cur.right && this._compare(cur.right.key, key) === CP.gt)
                     _traverse(cur.right);
             };
             _traverse(this.root);
@@ -419,12 +416,12 @@ export class BST extends BinaryTree {
             while (queue.length > 0) {
                 const cur = queue.shift();
                 if (cur) {
-                    const compared = this._compare(cur.id, id);
+                    const compared = this._compare(cur.key, key);
                     if (compared === CP.gt)
                         _sumByPropertyName(cur);
-                    if (cur.left && this._compare(cur.left.id, id) === CP.gt)
+                    if (cur.left && this._compare(cur.left.key, key) === CP.gt)
                         queue.push(cur.left);
-                    if (cur.right && this._compare(cur.right.id, id) === CP.gt)
+                    if (cur.right && this._compare(cur.right.key, key) === CP.gt)
                         queue.push(cur.right);
                 }
             }
@@ -446,7 +443,7 @@ export class BST extends BinaryTree {
      * @returns The function `perfectlyBalance()` returns a boolean value.
      */
     perfectlyBalance() {
-        const sorted = this.DFS('in', 'node'), n = sorted.length;
+        const sorted = this.dfs('in', 'node'), n = sorted.length;
         this.clear();
         if (sorted.length < 1)
             return false;
@@ -456,7 +453,7 @@ export class BST extends BinaryTree {
                     return;
                 const m = l + Math.floor((r - l) / 2);
                 const midNode = sorted[m];
-                this.add(midNode.id, midNode.val);
+                this.add(midNode.key, midNode.val);
                 buildBalanceBST(l, m - 1);
                 buildBalanceBST(m + 1, r);
             };
@@ -472,7 +469,7 @@ export class BST extends BinaryTree {
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
                         const midNode = sorted[m];
-                        this.add(midNode.id, midNode.val);
+                        this.add(midNode.key, midNode.val);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
                     }
@@ -534,8 +531,8 @@ export class BST extends BinaryTree {
     /**
      * 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.
-     * @param {BinaryTreeNodeId} a - a is a BinaryTreeNodeId, which represents the identifier of a binary tree node.
-     * @param {BinaryTreeNodeId} b - The parameter "b" in the above code refers to a BinaryTreeNodeId.
+     * @param {BinaryTreeNodeKey} a - "a" is a BinaryTreeNodeKey, which represents the identifier of a binary tree node.
+     * @param {BinaryTreeNodeKey} b - The parameter "b" in the above code refers to a BinaryTreeNodeKey.
      * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater than), CP.lt (less
      * than), or CP.eq (equal).
      */

package/lib/data-structures/binary-tree/rb-tree.d.ts

@@ -1,13 +1,13 @@
-import { BinaryTreeNodeId, RBColor, RBTreeNodeNested, RBTreeOptions } from '../../types';
+import { BinaryTreeNodeKey, RBColor, RBTreeNodeNested, RBTreeOptions } from '../../types';
 import { IRBTree, IRBTreeNode } from '../../interfaces';
 import { BST, BSTNode } from './bst';
 export declare class RBTreeNode<V = any, NEIGHBOR extends RBTreeNode<V, NEIGHBOR> = RBTreeNodeNested<V>> extends BSTNode<V, NEIGHBOR> implements IRBTreeNode<V, NEIGHBOR> {
     private _color;
-    constructor(id: BinaryTreeNodeId, val?: V);
+    constructor(key: BinaryTreeNodeKey, val?: V);
     get color(): RBColor;
     set color(value: RBColor);
 }
 export declare class RBTree<N extends RBTreeNode<N['val'], N> = RBTreeNode> extends BST<N> implements IRBTree<N> {
     constructor(options?: RBTreeOptions);
-    createNode(id: BinaryTreeNodeId, val?: N['val']): N;
+    createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
 }

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

@@ -1,8 +1,8 @@
 import { RBColor } from '../../types';
 import { BST, BSTNode } from './bst';
 export class RBTreeNode extends BSTNode {
-    constructor(id, val) {
-        super(id, val);
+    constructor(key, val) {
+        super(key, val);
         this._color = RBColor.RED;
     }
     get color() {
@@ -16,7 +16,7 @@ export class RBTree extends BST {
     constructor(options) {
         super(options);
     }
-    createNode(id, val) {
-        return new RBTreeNode(id, val);
+    createNode(key, val) {
+        return new RBTreeNode(key, val);
     }
 }