data-structure-typed 1.34.8 → 1.34.9

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

@@ -9,28 +9,15 @@ import { trampoline } from '../../utils';
 import { FamilyPosition, LoopType } from '../../types';
 export class AbstractBinaryTreeNode {
     /**
-     * The constructor function initializes a BinaryTreeNode object with an key and an optional value.
+     * The constructor function initializes a BinaryTreeNode object with a key and an optional value.
      * @param {BinaryTreeNodeKey} key - The `key` parameter is of type `BinaryTreeNodeKey` and represents the unique identifier
      * of the binary tree node. It is used to distinguish one node from another in the binary tree.
      * @param {V} [val] - The "val" parameter is an optional parameter of type V. It represents the value that will be
      * stored in the binary tree node. If no value is provided, it will be set to undefined.
      */
     constructor(key, val) {
-        this._height = 0;
-        this._key = key;
-        this._val = val;
-    }
-    get key() {
-        return this._key;
-    }
-    set key(v) {
-        this._key = v;
-    }
-    get val() {
-        return this._val;
-    }
-    set val(value) {
-        this._val = value;
+        this.key = key;
+        this.val = val;
     }
     get left() {
         return this._left;
@@ -50,18 +37,6 @@ export class AbstractBinaryTreeNode {
         }
         this._right = v;
     }
-    get parent() {
-        return this._parent;
-    }
-    set parent(v) {
-        this._parent = v;
-    }
-    get height() {
-        return this._height;
-    }
-    set height(v) {
-        this._height = v;
-    }
     /**
      * The function determines the position of a node in a family tree structure.
      * @returns a value of type `FamilyPosition`.
@@ -110,9 +85,9 @@ export class AbstractBinaryTree {
         this._root = null;
         this._size = 0;
         this._loopType = LoopType.ITERATIVE;
-        this._visitedKey = [];
-        this._visitedVal = [];
-        this._visitedNode = [];
+        this.visitedKey = [];
+        this.visitedVal = [];
+        this.visitedNode = [];
         if (options !== undefined) {
             const { loopType = LoopType.ITERATIVE } = options;
             this._loopType = loopType;
@@ -128,15 +103,6 @@ export class AbstractBinaryTree {
     get loopType() {
         return this._loopType;
     }
-    get visitedKey() {
-        return this._visitedKey;
-    }
-    get visitedVal() {
-        return this._visitedVal;
-    }
-    get visitedNode() {
-        return this._visitedNode;
-    }
     /**
      * The `swapLocation` function swaps the location of two nodes in a binary tree.
      * @param {N} srcNode - The source node that you want to swap with the destination node.
@@ -145,16 +111,13 @@ export class AbstractBinaryTree {
      * @returns The `destNode` is being returned.
      */
     swapLocation(srcNode, destNode) {
-        const { key, val, height } = destNode;
+        const { key, val } = destNode;
         const tempNode = this.createNode(key, val);
         if (tempNode) {
-            tempNode.height = height;
             destNode.key = srcNode.key;
             destNode.val = srcNode.val;
-            destNode.height = srcNode.height;
             srcNode.key = tempNode.key;
             srcNode.val = tempNode.val;
-            srcNode.height = tempNode.height;
         }
         return destNode;
     }
@@ -245,18 +208,18 @@ export class AbstractBinaryTree {
     /**
      * The `addMany` function takes an array of binary tree node IDs or nodes, and optionally an array of corresponding data
      * values, and adds them to the binary tree.
-     * @param {(BinaryTreeNodeKey | null)[] | (N | null)[]} idsOrNodes - An array of BinaryTreeNodeKey or BinaryTreeNode
+     * @param {(BinaryTreeNodeKey | null)[] | (N | null)[]} keysOrNodes - An array of BinaryTreeNodeKey or BinaryTreeNode
      * objects, or null values.
      * @param {N['val'][]} [data] - The `data` parameter is an optional array of values (`N['val'][]`) that corresponds to
      * the nodes or node IDs being added. It is used to set the value of each node being added. If `data` is not provided,
      * the value of the nodes will be `undefined`.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(idsOrNodes, data) {
+    addMany(keysOrNodes, data) {
         // TODO not sure addMany not be run multi times
         const inserted = [];
-        for (let i = 0; i < idsOrNodes.length; i++) {
-            const keyOrNode = idsOrNodes[i];
+        for (let i = 0; i < keysOrNodes.length; i++) {
+            const keyOrNode = keysOrNodes[i];
             if (keyOrNode instanceof AbstractBinaryTreeNode) {
                 inserted.push(this.add(keyOrNode.key, keyOrNode.val));
                 continue;
@@ -271,17 +234,17 @@ export class AbstractBinaryTree {
         return inserted;
     }
     /**
-     * The `fill` function clears the binary tree and adds multiple nodes with the given IDs or nodes and optional data.
-     * @param {(BinaryTreeNodeKey | N)[]} idsOrNodes - The `idsOrNodes` parameter is an array that can contain either
+     * The `refill` function clears the binary tree and adds multiple nodes with the given IDs or nodes and optional data.
+     * @param {(BinaryTreeNodeKey | N)[]} keysOrNodes - The `keysOrNodes` parameter is an array that can contain either
      * `BinaryTreeNodeKey` or `N` values.
      * @param {N[] | Array<N['val']>} [data] - The `data` parameter is an optional array of values that will be assigned to
-     * the nodes being added. If provided, the length of the `data` array should be equal to the length of the `idsOrNodes`
+     * the nodes being added. If provided, the length of the `data` array should be equal to the length of the `keysOrNodes`
      * array. Each value in the `data` array will be assigned to the
      * @returns The method is returning a boolean value.
      */
-    fill(idsOrNodes, data) {
+    refill(keysOrNodes, data) {
         this.clear();
-        return idsOrNodes.length === this.addMany(idsOrNodes, data).length;
+        return keysOrNodes.length === this.addMany(keysOrNodes, data).length;
     }
     /**
      * The `remove` function in TypeScript is used to delete a node from a binary search tree and returns an array of objects
@@ -338,7 +301,7 @@ export class AbstractBinaryTree {
      * @param {N | BinaryTreeNodeKey | null} beginRoot - The `beginRoot` parameter can be one of the following:
      * @returns the depth of the given node or binary tree.
      */
-    getDepth(beginRoot) {
+    getDepth(beginRoot = this.root) {
         if (typeof beginRoot === 'number')
             beginRoot = this.get(beginRoot, 'key');
         let depth = 0;
@@ -355,8 +318,7 @@ export class AbstractBinaryTree {
      * node), or `null`.
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot) {
-        beginRoot = beginRoot !== null && beginRoot !== void 0 ? beginRoot : this.root;
+    getHeight(beginRoot = this.root) {
         if (typeof beginRoot === 'number')
             beginRoot = this.get(beginRoot, 'key');
         if (!beginRoot)
@@ -398,9 +360,8 @@ export class AbstractBinaryTree {
      * for `beginRoot`, the `this.root` property is used as the default value.
      * @returns The function `getMinHeight` returns the minimum height of the binary tree.
      */
-    getMinHeight(beginRoot) {
+    getMinHeight(beginRoot = this.root) {
         var _a, _b, _c;
-        beginRoot = beginRoot || this.root;
         if (!beginRoot)
             return -1;
         if (this._loopType === LoopType.RECURSIVE) {
@@ -450,7 +411,7 @@ export class AbstractBinaryTree {
      * tree or null if the tree is empty.
      * @returns The method is returning a boolean value.
      */
-    isPerfectlyBalanced(beginRoot) {
+    isPerfectlyBalanced(beginRoot = this.root) {
         return this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot);
     }
     /**
@@ -464,10 +425,9 @@ export class AbstractBinaryTree {
      * function will stop traversing the tree and return the first matching node. If `only
      * @returns an array of nodes (type N).
      */
-    getNodes(nodeProperty, propertyName, onlyOne) {
+    getNodes(nodeProperty, propertyName = 'key', onlyOne = false) {
         if (!this.root)
             return [];
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'key';
         const result = [];
         if (this.loopType === LoopType.RECURSIVE) {
             const _traverse = (cur) => {
@@ -502,8 +462,7 @@ export class AbstractBinaryTree {
      * specifies the name of the property to be checked in the nodes. If not provided, it defaults to 'key'.
      * @returns a boolean value.
      */
-    has(nodeProperty, propertyName) {
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'key';
+    has(nodeProperty, propertyName = 'key') {
         // TODO may support finding node by value equal
         return this.getNodes(nodeProperty, propertyName).length > 0;
     }
@@ -518,9 +477,8 @@ export class AbstractBinaryTree {
      * @returns either the value of the specified property of the node, or the node itself if no property name is provided.
      * If no matching node is found, it returns null.
      */
-    get(nodeProperty, propertyName) {
+    get(nodeProperty, propertyName = 'key') {
         var _a;
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'key';
         // TODO may support finding node by value equal
         return (_a = this.getNodes(nodeProperty, propertyName, true)[0]) !== null && _a !== void 0 ? _a : null;
     }
@@ -557,10 +515,9 @@ export class AbstractBinaryTree {
      * from the root of the binary tree. The function returns the leftmost node found during the traversal. If no leftmost
      * node is found (
      */
-    getLeftMost(beginRoot) {
+    getLeftMost(beginRoot = this.root) {
         if (typeof beginRoot === 'number')
             beginRoot = this.get(beginRoot, 'key');
-        beginRoot = beginRoot !== null && beginRoot !== void 0 ? beginRoot : this.root;
         if (!beginRoot)
             return beginRoot;
         if (this._loopType === LoopType.RECURSIVE) {
@@ -584,25 +541,24 @@ export class AbstractBinaryTree {
     /**
      * The `getRightMost` function returns the rightmost node in a binary tree, either recursively or iteratively using tail
      * recursion optimization.
-     * @param {N | null} [node] - The `node` parameter is an optional parameter of type `N` or `null`. It represents the
+     * @param {N | null} [beginRoot] - The `node` parameter is an optional parameter of type `N` or `null`. It represents the
      * starting node from which we want to find the rightmost node. If no node is provided, the function will default to
      * using the root node of the data structure.
      * @returns The `getRightMost` function returns the rightmost node in a binary tree. If the `node` parameter is provided,
      * it returns the rightmost node starting from that node. If the `node` parameter is not provided, it returns the
      * rightmost node starting from the root of the binary tree.
      */
-    getRightMost(node) {
+    getRightMost(beginRoot = this.root) {
         // TODO support get right most by passing key in
-        node = node !== null && node !== void 0 ? node : this.root;
-        if (!node)
-            return node;
+        if (!beginRoot)
+            return beginRoot;
         if (this._loopType === LoopType.RECURSIVE) {
             const _traverse = (cur) => {
                 if (!cur.right)
                     return cur;
                 return _traverse(cur.right);
             };
-            return _traverse(node);
+            return _traverse(beginRoot);
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
@@ -611,7 +567,7 @@ export class AbstractBinaryTree {
                     return cur;
                 return _traverse.cont(cur.right);
             });
-            return _traverse(node);
+            return _traverse(beginRoot);
         }
     }
     /**
@@ -697,8 +653,7 @@ export class AbstractBinaryTree {
      * not provided, it defaults to 'key'.
      * @returns a number, which is the sum of the values of the specified property in the subtree rooted at `subTreeRoot`.
      */
-    subTreeSum(subTreeRoot, propertyName) {
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'key';
+    subTreeSum(subTreeRoot, propertyName = 'key') {
         if (typeof subTreeRoot === 'number')
             subTreeRoot = this.get(subTreeRoot, 'key');
         if (!subTreeRoot)
@@ -748,8 +703,7 @@ export class AbstractBinaryTree {
      * specifies the property of the binary tree node that should be modified. If not provided, it defaults to 'key'.
      * @returns a boolean value.
      */
-    subTreeAdd(subTreeRoot, delta, propertyName) {
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'key';
+    subTreeAdd(subTreeRoot, delta, propertyName = 'key') {
         if (typeof subTreeRoot === 'number')
             subTreeRoot = this.get(subTreeRoot, 'key');
         if (!subTreeRoot)
@@ -784,14 +738,13 @@ export class AbstractBinaryTree {
         return true;
     }
     /**
-     * The BFS function performs a breadth-first search on a binary tree, accumulating properties of each node based on a specified property name.
+     * The bfs function performs a breadth-first search on a binary tree, accumulating properties of each node based on a specified property name.
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - An optional parameter that represents either a node or a property name.
-     * If a node is provided, the BFS algorithm will be performed starting from that node.
-     * If a property name is provided, the BFS algorithm will be performed starting from the root node, accumulating the specified property.
+     * If a node is provided, the bfs algorithm will be performed starting from that node.
+     * If a property name is provided, the bfs algorithm will be performed starting from the root node, accumulating the specified property.
      * @returns An instance of the `AbstractBinaryTreeNodeProperties` class with generic type `N`.
      */
-    BFS(nodeOrPropertyName) {
-        nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'key';
+    bfs(nodeOrPropertyName = 'key') {
         this._clearResults();
         const queue = [this.root];
         while (queue.length !== 0) {
@@ -807,15 +760,13 @@ export class AbstractBinaryTree {
         return this._getResultByPropertyName(nodeOrPropertyName);
     }
     /**
-     * The DFS function performs a depth-first search traversal on a binary tree and returns the accumulated properties of
+     * The dfs function performs a depth-first search traversal on a binary tree and returns the accumulated properties of
      * each node based on the specified pattern and property name.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The name of a property of the nodes in the binary tree. This property will be used to accumulate values during the depth-first search traversal. If no `nodeOrPropertyName` is provided, the default value is `'key'`.
      * @returns an instance of the AbstractBinaryTreeNodeProperties class, which contains the accumulated properties of the binary tree nodes based on the specified pattern and node or property name.
      */
-    DFS(pattern, nodeOrPropertyName) {
-        pattern = pattern !== null && pattern !== void 0 ? pattern : 'in';
-        nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'key';
+    dfs(pattern = 'in', nodeOrPropertyName = 'key') {
         this._clearResults();
         const _traverse = (node) => {
             switch (pattern) {
@@ -846,15 +797,13 @@ export class AbstractBinaryTree {
         return this._getResultByPropertyName(nodeOrPropertyName);
     }
     /**
-     * The DFSIterative function performs an iterative depth-first search traversal on a binary tree, with the option to
+     * The dfsIterative function performs an iterative depth-first search traversal on a binary tree, with the option to
      * specify the traversal pattern and the property name to accumulate results by.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The name of a property of the nodes in the binary tree. This property will be used to accumulate values during the depth-first search traversal. By default, it is set to `'key'`.
      * @returns An object of type AbstractBinaryTreeNodeProperties<N>.
      */
-    DFSIterative(pattern, nodeOrPropertyName) {
-        pattern = pattern || 'in';
-        nodeOrPropertyName = nodeOrPropertyName || 'key';
+    dfsIterative(pattern = 'in', nodeOrPropertyName = 'key') {
         this._clearResults();
         if (!this.root)
             return this._getResultByPropertyName(nodeOrPropertyName);
@@ -906,9 +855,7 @@ export class AbstractBinaryTree {
      * accumulating results based on the 'key' property.
      * @returns An object of type `AbstractBinaryTreeNodeProperties<N>`.
      */
-    levelIterative(node, nodeOrPropertyName) {
-        nodeOrPropertyName = nodeOrPropertyName || 'key';
-        node = node || this.root;
+    levelIterative(node = this.root, nodeOrPropertyName = 'key') {
         if (!node)
             return [];
         this._clearResults();
@@ -933,9 +880,7 @@ export class AbstractBinaryTree {
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is an optional parameter that specifies the property of the `BinaryTreeNode` object to collect at each level. It can be one of the following values: 'key', 'val', or 'node'. If not provided, it defaults to 'key'.
      * @returns A 2D array of `AbstractBinaryTreeNodeProperty<N>` objects.
      */
-    listLevels(node, nodeOrPropertyName) {
-        nodeOrPropertyName = nodeOrPropertyName || 'key';
-        node = node || this.root;
+    listLevels(node = this.root, nodeOrPropertyName = 'key') {
         if (!node)
             return [];
         const levelsNodes = [];
@@ -1008,11 +953,9 @@ export class AbstractBinaryTree {
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The property name of the nodes to retrieve or perform operations on during the traversal. It can be any valid property name of the nodes in the binary tree. If not provided, it defaults to 'key'.
      * @returns An array of AbstractBinaryTreeNodeProperties<N> objects.
      */
-    morris(pattern, nodeOrPropertyName) {
+    morris(pattern = 'in', nodeOrPropertyName = 'key') {
         if (this.root === null)
             return [];
-        pattern = pattern || 'in';
-        nodeOrPropertyName = nodeOrPropertyName || 'key';
         this._clearResults();
         let cur = this.root;
         const _reverseEdge = (node) => {
@@ -1137,27 +1080,6 @@ export class AbstractBinaryTree {
     _setLoopType(value) {
         this._loopType = value;
     }
-    /**
-     * The function sets the value of the `_visitedKey` property in a protected manner.
-     * @param {BinaryTreeNodeKey[]} value - value is an array of BinaryTreeNodeKey values.
-     */
-    _setVisitedKey(value) {
-        this._visitedKey = value;
-    }
-    /**
-     * The function sets the value of the "_visitedVal" property to the given array.
-     * @param value - An array of type N.
-     */
-    _setVisitedVal(value) {
-        this._visitedVal = value;
-    }
-    /**
-     * The function sets the value of the _visitedNode property.
-     * @param {N[]} value - N[] is an array of elements of type N.
-     */
-    _setVisitedNode(value) {
-        this._visitedNode = value;
-    }
     /**
      * The function sets the root property of an object to a given value, and if the value is not null, it also sets the
      * parent property of the value to undefined.
@@ -1181,9 +1103,9 @@ export class AbstractBinaryTree {
      * properties.
      */
     _clearResults() {
-        this._visitedKey = [];
-        this._visitedVal = [];
-        this._visitedNode = [];
+        this.visitedKey = [];
+        this.visitedVal = [];
+        this.visitedNode = [];
     }
     /**
      * The function checks if a given property of a binary tree node matches a specified value, and if so, adds the node to
@@ -1200,24 +1122,24 @@ export class AbstractBinaryTree {
      * `true`, the function will stop after finding the first matching node and return `true`. If `onlyOne
      * @returns a boolean value indicating whether only one matching node should be pushed into the result array.
      */
-    _pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne) {
+    _pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName = 'key', onlyOne = false) {
         switch (propertyName) {
             case 'key':
                 if (cur.key === nodeProperty) {
                     result.push(cur);
-                    return !!onlyOne;
+                    return onlyOne;
                 }
                 break;
             case 'val':
                 if (cur.val === nodeProperty) {
                     result.push(cur);
-                    return !!onlyOne;
+                    return onlyOne;
                 }
                 break;
             default:
                 if (cur.key === nodeProperty) {
                     result.push(cur);
-                    return !!onlyOne;
+                    return onlyOne;
                 }
                 break;
         }
@@ -1229,25 +1151,24 @@ export class AbstractBinaryTree {
      * can be either a string representing a property name or a reference to a `Node` object. If it is a string, it
      * specifies the property name to be used for accumulating values. If it is a `Node` object, it specifies
      */
-    _accumulatedByPropertyName(node, nodeOrPropertyName) {
-        nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'key';
+    _accumulatedByPropertyName(node, nodeOrPropertyName = 'key') {
         switch (nodeOrPropertyName) {
             case 'key':
-                this._visitedKey.push(node.key);
+                this.visitedKey.push(node.key);
                 break;
             case 'val':
-                this._visitedVal.push(node.val);
+                this.visitedVal.push(node.val);
                 break;
             case 'node':
-                this._visitedNode.push(node);
+                this.visitedNode.push(node);
                 break;
             default:
-                this._visitedKey.push(node.key);
+                this.visitedKey.push(node.key);
                 break;
         }
     }
     /**
-     * The time complexity of Morris traversal is O(n), it's may slower than others
+     * The time complexity of Morris traversal is O(n), it may slower than others
      * The space complexity  Morris traversal is O(1) because no using stack
      */
     /**
@@ -1257,17 +1178,16 @@ export class AbstractBinaryTree {
      * can accept either a `NodeOrPropertyName` type or be undefined.
      * @returns The method `_getResultByPropertyName` returns an instance of `AbstractBinaryTreeNodeProperties<N>`.
      */
-    _getResultByPropertyName(nodeOrPropertyName) {
-        nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'key';
+    _getResultByPropertyName(nodeOrPropertyName = 'key') {
         switch (nodeOrPropertyName) {
             case 'key':
-                return this._visitedKey;
+                return this.visitedKey;
             case 'val':
-                return this._visitedVal;
+                return this.visitedVal;
             case 'node':
-                return this._visitedNode;
+                return this.visitedNode;
             default:
-                return this._visitedKey;
+                return this.visitedKey;
         }
     }
 }

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

@@ -9,6 +9,7 @@ import { BST, BSTNode } from './bst';
 import type { AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeletedResult, BinaryTreeNodeKey } from '../../types';
 import { IAVLTree, IAVLTreeNode } from '../../interfaces';
 export declare class AVLTreeNode<V = any, NEIGHBOR extends AVLTreeNode<V, NEIGHBOR> = AVLTreeNodeNested<V>> extends BSTNode<V, NEIGHBOR> implements IAVLTreeNode<V, NEIGHBOR> {
+    height: number;
     constructor(key: BinaryTreeNodeKey, val?: V);
 }
 export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends BST<N> implements IAVLTree<N> {
@@ -19,6 +20,14 @@ export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> e
      * options.
      */
     constructor(options?: AVLTreeOptions);
+    /**
+     * The `swapLocation` function swaps the location of two nodes in a binary tree.
+     * @param {N} srcNode - The source node that you want to swap with the destination node.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values from `srcNode` will
+     * be swapped to.
+     * @returns The `destNode` is being returned.
+     */
+    swapLocation(srcNode: N, destNode: N): N;
     /**
      * The function creates a new AVL 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

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

@@ -9,6 +9,7 @@ import { BST, BSTNode } from './bst';
 export class AVLTreeNode extends BSTNode {
     constructor(key, val) {
         super(key, val);
+        this.height = 0;
     }
 }
 export class AVLTree extends BST {
@@ -21,6 +22,27 @@ export class AVLTree extends BST {
     constructor(options) {
         super(options);
     }
+    /**
+     * The `swapLocation` function swaps the location of two nodes in a binary tree.
+     * @param {N} srcNode - The source node that you want to swap with the destination node.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values from `srcNode` will
+     * be swapped to.
+     * @returns The `destNode` is being returned.
+     */
+    swapLocation(srcNode, destNode) {
+        const { key, val, height } = destNode;
+        const tempNode = this.createNode(key, val);
+        if (tempNode) {
+            tempNode.height = height;
+            destNode.key = srcNode.key;
+            destNode.val = srcNode.val;
+            destNode.height = srcNode.height;
+            srcNode.key = tempNode.key;
+            srcNode.val = tempNode.val;
+            srcNode.height = tempNode.height;
+        }
+        return destNode;
+    }
     /**
      * The function creates a new AVL 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

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

@@ -40,14 +40,14 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
     /**
      * The `addMany` function overrides the base class method to add multiple nodes to a binary search tree in a balanced
      * manner.
-     * @param {[BinaryTreeNodeKey | N , N['val']][]} idsOrNodes - The `idsOrNodes` parameter in the `addMany` function is an array of
+     * @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: (BinaryTreeNodeKey | null)[] | (N | null)[], data?: N['val'][], isBalanceAdd?: boolean): (N | null | undefined)[];
+    addMany(keysOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[], data?: N['val'][], isBalanceAdd?: boolean): (N | null | undefined)[];
     /**
      * The function returns the first node in a binary tree that matches the given property name and value.
      * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or a
@@ -124,7 +124,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
     /**
      * 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 {BinaryTreeNodeKey} a - a is a BinaryTreeNodeKey, which represents the identifier of a binary tree node.
+     * @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).