data-structure-typed 1.37.3 → 1.37.4

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

@@ -23,11 +23,12 @@ export class AVLTree extends BST {
         super(options);
     }
     /**
-     * The `_swap` 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.
+     * The function swaps the key, value, and height properties between two nodes in a binary tree.
+     * @param {N} srcNode - The `srcNode` parameter represents the source node that needs to be swapped
+     * with the `destNode`.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
+     * from the source node (`srcNode`) will be swapped to.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
      */
     _swap(srcNode, destNode) {
         const { key, val, height } = destNode;
@@ -44,22 +45,25 @@ export class AVLTree extends BST {
         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
-     * identify each node in the 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.
+     * The function creates a new AVL tree node with the specified key and value.
+     * @param {BinaryTreeNodeKey} key - The key parameter is the key value that will be associated with
+     * the new node. It is used to determine the position of the node in the binary search tree.
+     * @param [val] - The parameter `val` is an optional value that can be assigned to the node. It is of
+     * type `N['val']`, which means it can be any value that is assignable to the `val` property of the
+     * node type `N`.
      * @returns a new AVLTreeNode object with the specified key and value.
      */
     createNode(key, val) {
         return new AVLTreeNode(key, val);
     }
     /**
-     * The function overrides the add method of a binary tree node and balances the tree after inserting a new node.
-     * @param keyOrNode - The `keyOrNode` parameter is either a key or a node that needs to be added to the binary tree.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. It is of type
-     * `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.
+     * The function overrides the add method of a binary tree node and balances the tree after inserting
+     * a new node.
+     * @param {BinaryTreeNodeKey | N | null} keyOrNode - The `keyOrNode` parameter can accept either a
+     * `BinaryTreeNodeKey` or a `N` (which represents a node in the binary tree) or `null`.
+     * @param [val] - The `val` parameter is the value that you want to assign to the new node that you
+     * are adding to the binary search tree.
+     * @returns The method is returning the inserted node (`N`), `null`, or `undefined`.
      */
     add(keyOrNode, val) {
         // TODO support node as a param
@@ -69,9 +73,11 @@ export class AVLTree extends BST {
         return inserted;
     }
     /**
-     * The function overrides the delete method of a binary tree and performs additional operations to balance the tree after deletion.
+     * The function overrides the delete method of a binary tree and balances the tree after deleting a
+     * node if necessary.
+     * @param {N | BinaryTreeNodeKey} nodeOrKey - The `nodeOrKey` parameter can be either a node object
+     * (`N`) or a key value (`BinaryTreeNodeKey`).
      * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
-     * @param nodeOrKey - The `nodeOrKey` parameter is either a node or a key that needs to be deleted from the binary tree.
      */
     delete(nodeOrKey) {
         const deletedResults = super.delete(nodeOrKey);
@@ -83,10 +89,10 @@ export class AVLTree extends BST {
         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.
+     * The function calculates the balance factor of a node in a binary tree.
+     * @param {N} node - The parameter "node" represents a node in a binary tree data structure.
+     * @returns the balance factor of a given node. The balance factor is calculated by subtracting the
+     * height of the left subtree from the height of the right subtree.
      */
     _balanceFactor(node) {
         if (!node.right)
@@ -99,8 +105,9 @@ export class AVLTree extends BST {
             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.
+     * The function updates the height of a node in a binary tree based on the heights of its left and
+     * right children.
+     * @param {N} node - The parameter "node" represents a node in a binary tree data structure.
      */
     _updateHeight(node) {
         if (!node.left && !node.right)
@@ -115,9 +122,10 @@ export class AVLTree extends BST {
             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.
+     * The `_balancePath` function is used to update the heights of nodes and perform rotation operations
+     * to restore balance in an AVL tree after inserting a node.
+     * @param {N} node - The `node` parameter in the `_balancePath` function represents the node in the
+     * AVL tree that needs to be balanced.
      */
     _balancePath(node) {
         const path = this.getPathToRoot(node, false); // first O(log n) + O(log n)
@@ -159,8 +167,8 @@ export class AVLTree extends BST {
         }
     }
     /**
-     * The `_balanceLL` function performs a left-left rotation on an AVL tree to balance it.
-     * @param A - The parameter A is an AVLTreeNode object.
+     * The function `_balanceLL` performs a left-left rotation to balance a binary tree.
+     * @param {N} A - A is a node in a binary tree.
      */
     _balanceLL(A) {
         const parentOfA = A.parent;
@@ -193,8 +201,8 @@ export class AVLTree extends BST {
             this._updateHeight(B);
     }
     /**
-     * The `_balanceLR` function performs a left-right rotation to balance an AVL tree.
-     * @param A - A is an AVLTreeNode object.
+     * The `_balanceLR` function performs a left-right rotation to balance a binary tree.
+     * @param {N} A - A is a node in a binary tree.
      */
     _balanceLR(A) {
         const parentOfA = A.parent;
@@ -242,8 +250,8 @@ export class AVLTree extends BST {
         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.
+     * The function `_balanceRR` performs a right-right rotation to balance a binary tree.
+     * @param {N} A - A is a node in a binary tree.
      */
     _balanceRR(A) {
         const parentOfA = A.parent;
@@ -277,8 +285,8 @@ export class AVLTree extends BST {
         B && this._updateHeight(B);
     }
     /**
-     * The `_balanceRL` function performs a right-left rotation to balance an AVL tree.
-     * @param A - A is an AVLTreeNode object.
+     * The function `_balanceRL` performs a right-left rotation to balance a binary tree.
+     * @param {N} A - A is a node in a binary tree.
      */
     _balanceRL(A) {
         const parentOfA = A.parent;