bst-typed 1.49.5 → 1.49.6

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

@@ -24,11 +24,11 @@ exports.TreeMultimapNode = TreeMultimapNode;
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 class TreeMultimap extends avl_tree_1.AVLTree {
-    constructor(elements, options) {
+    constructor(nodes, options) {
         super([], options);
         this._count = 0;
-        if (elements)
-            this.addMany(elements);
+        if (nodes)
+            this.addMany(nodes);
     }
     // TODO the _count is not accurate after nodes count modified
     get count() {
@@ -52,26 +52,8 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         return new TreeMultimap([], Object.assign({ iterationType: this.iterationType, variant: this.variant }, options));
     }
     /**
-     * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
-     * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
-     * class.
-     */
-    isNode(exemplar) {
-        return exemplar instanceof TreeMultimapNode;
-    }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-        return !(potentialKey instanceof TreeMultimapNode);
-    }
-    /**
-     * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, which means it
+     * The function `exemplarToNode` converts an keyOrNodeOrEntry object into a node object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
@@ -80,16 +62,16 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * times the value should be added to the node. If not provided, it defaults to 1.
      * @returns a node of type `N` or `undefined`.
      */
-    exemplarToNode(exemplar, value, count = 1) {
+    exemplarToNode(keyOrNodeOrEntry, value, count = 1) {
         let node;
-        if (exemplar === undefined || exemplar === null) {
+        if (keyOrNodeOrEntry === undefined || keyOrNodeOrEntry === null) {
             return;
         }
-        else if (this.isNode(exemplar)) {
-            node = exemplar;
+        else if (this.isNode(keyOrNodeOrEntry)) {
+            node = keyOrNodeOrEntry;
         }
-        else if (this.isEntry(exemplar)) {
-            const [key, value] = exemplar;
+        else if (this.isEntry(keyOrNodeOrEntry)) {
+            const [key, value] = keyOrNodeOrEntry;
             if (key === undefined || key === null) {
                 return;
             }
@@ -97,8 +79,8 @@ class TreeMultimap extends avl_tree_1.AVLTree {
                 node = this.createNode(key, value, count);
             }
         }
-        else if (this.isNotNodeInstance(exemplar)) {
-            node = this.createNode(exemplar, value, count);
+        else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+            node = this.createNode(keyOrNodeOrEntry, value, count);
         }
         else {
             return;
@@ -106,12 +88,31 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         return node;
     }
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * The function checks if an keyOrNodeOrEntry is an instance of the TreeMultimapNode class.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the TreeMultimapNode
+     * class.
      */
+    isNode(keyOrNodeOrEntry) {
+        return keyOrNodeOrEntry instanceof TreeMultimapNode;
+    }
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof TreeMultimapNode);
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The function overrides the add method of a binary tree node and adds a new node to the tree.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
@@ -128,21 +129,22 @@ class TreeMultimap extends avl_tree_1.AVLTree {
     add(keyOrNodeOrEntry, value, count = 1) {
         const newNode = this.exemplarToNode(keyOrNodeOrEntry, value, count);
         if (newNode === undefined)
-            return;
+            return false;
         const orgNodeCount = (newNode === null || newNode === void 0 ? void 0 : newNode.count) || 0;
         const inserted = super.add(newNode);
         if (inserted) {
             this._count += orgNodeCount;
         }
-        return inserted;
+        return true;
     }
     /**
-     * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
+     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
      *
      * The function overrides the addMany method to add multiple keys, nodes, or entries to a data
      * structure.
@@ -154,12 +156,13 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         return super.addMany(keysOrNodesOrEntries);
     }
     /**
-     * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     * logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node. linear space, as it creates an array to store the sorted nodes.
      */
     /**
-     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
-     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      *
      * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
      * tree using either a recursive or iterative approach.
@@ -205,12 +208,13 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         }
     }
     /**
-     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
+     * logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
      *
      * The `delete` function in TypeScript is used to remove a node from a binary tree, taking into
      * account the count of the node and balancing the tree if necessary.
@@ -286,10 +290,13 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         return deletedResult;
     }
     /**
-     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
-     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
     clear() {

package/dist/interfaces/binary-tree.d.ts

@@ -1,9 +1,9 @@
 import { BinaryTree, BinaryTreeNode } from '../data-structures';
-import { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, BTNExemplar } from '../types';
+import { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, KeyOrNodeOrEntry } from '../types';
 export interface IBinaryTree<K = number, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNodeNested<K, V>, TREE extends BinaryTree<K, V, N, TREE> = BinaryTreeNested<K, V, N>> {
     createNode(key: K, value?: N['value']): N;
     createTree(options?: Partial<BinaryTreeOptions<K>>): TREE;
-    add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V, count?: number): N | null | undefined;
-    addMany(nodes: Iterable<BTNExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[];
+    add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V, count?: number): boolean;
+    addMany(nodes: Iterable<KeyOrNodeOrEntry<K, V, N>>, values?: Iterable<V | undefined>): boolean[];
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeleteResult<N>[];
 }

package/dist/types/common.d.ts

@@ -1,6 +1,6 @@
 export declare enum BSTVariant {
-    MIN = "MIN",
-    MAX = "MAX"
+    STANDARD = "STANDARD",
+    INVERSE = "INVERSE"
 }
 export declare enum CP {
     lt = "lt",
@@ -44,7 +44,7 @@ export type BinaryTreePrintOptions = {
 };
 export type BTNEntry<K, V> = [K | null | undefined, V | undefined];
 export type BTNKeyOrNode<K, N> = K | null | undefined | N;
-export type BTNExemplar<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>;
+export type KeyOrNodeOrEntry<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>;
 export type BTNodePureKeyOrNode<K, N> = K | N;
 export type BTNodePureExemplar<K, V, N> = [K, V | undefined] | BTNodePureKeyOrNode<K, N>;
 export type BSTNKeyOrNode<K, N> = K | undefined | N;

package/dist/types/common.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FamilyPosition = exports.IterationType = exports.CP = exports.BSTVariant = void 0;
 var BSTVariant;
 (function (BSTVariant) {
-    BSTVariant["MIN"] = "MIN";
-    BSTVariant["MAX"] = "MAX";
+    BSTVariant["STANDARD"] = "STANDARD";
+    BSTVariant["INVERSE"] = "INVERSE";
 })(BSTVariant = exports.BSTVariant || (exports.BSTVariant = {}));
 var CP;
 (function (CP) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bst-typed",
-  "version": "1.49.5",
+  "version": "1.49.6",
   "description": "BST (Binary Search Tree). Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {

package/src/data-structures/binary-tree/avl-tree.ts

@@ -13,8 +13,7 @@ import type {
   BinaryTreeDeleteResult,
   BSTNKeyOrNode,
   BTNCallback,
-  BTNExemplar,
-  BTNKeyOrNode
+  KeyOrNodeOrEntry
 } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 
@@ -49,17 +48,17 @@ export class AVLTree<
   extends BST<K, V, N, TREE>
   implements IBinaryTree<K, V, N, TREE> {
   /**
-   * The constructor function initializes an AVLTree object with optional elements and options.
-   * @param [elements] - The `elements` parameter is an optional iterable of `BTNExemplar<K, V, N>`
-   * objects. It represents a collection of elements that will be added to the AVL tree during
+   * The constructor function initializes an AVLTree object with optional nodes and options.
+   * @param [nodes] - The `nodes` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+   * objects. It represents a collection of nodes that will be added to the AVL tree during
    * initialization.
    * @param [options] - The `options` parameter is an optional object that allows you to customize the
    * behavior of the AVL tree. It is of type `Partial<AVLTreeOptions>`, which means that you can
    * provide only a subset of the properties defined in the `AVLTreeOptions` interface.
    */
-  constructor(elements?: Iterable<BTNExemplar<K, V, N>>, options?: Partial<AVLTreeOptions<K>>) {
+  constructor(nodes?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: Partial<AVLTreeOptions<K>>) {
     super([], options);
-    if (elements) super.addMany(elements);
+    if (nodes) super.addMany(nodes);
   }
 
   /**
@@ -91,12 +90,12 @@ export class AVLTree<
   }
 
   /**
-   * The function checks if an exemplar is an instance of AVLTreeNode.
-   * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
-   * @returns a boolean value indicating whether the exemplar is an instance of the AVLTreeNode class.
+   * The function checks if an keyOrNodeOrEntry is an instance of AVLTreeNode.
+   * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+   * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the AVLTreeNode class.
    */
-  override isNode(exemplar: BTNExemplar<K, V, N>): exemplar is N {
-    return exemplar instanceof AVLTreeNode;
+  override isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>): keyOrNodeOrEntry is N {
+    return keyOrNodeOrEntry instanceof AVLTreeNode;
   }
 
   /**
@@ -105,18 +104,19 @@ export class AVLTree<
    * data type.
    * @returns a boolean value indicating whether the potentialKey is of type number or not.
    */
-  override isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K {
+  override isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K {
     return !(potentialKey instanceof AVLTreeNode);
   }
 
   /**
-   * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
-   * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
    */
 
   /**
-   * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
-   * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    *
    * The function overrides the add method of a binary tree node and balances the tree after inserting
    * a new node.
@@ -126,21 +126,21 @@ export class AVLTree<
    * being added to the binary tree.
    * @returns The method is returning either the inserted node or undefined.
    */
-  override add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V): N | undefined {
-    if (keyOrNodeOrEntry === null) return undefined;
+  override add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V): boolean {
+    if (keyOrNodeOrEntry === null) return false;
     const inserted = super.add(keyOrNodeOrEntry, value);
-    if (inserted) this._balancePath(inserted);
+    if (inserted) this._balancePath(keyOrNodeOrEntry);
     return inserted;
   }
 
   /**
-   * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
-   * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (BST) has logarithmic time complexity.
-   * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    *
    * The function overrides the delete method of a binary tree, performs the deletion, and then
    * balances the tree if necessary.
@@ -203,13 +203,14 @@ export class AVLTree<
   }
 
   /**
-   * Time Complexity: O(1) - constant time, as it performs a fixed number of operations.
-   * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   * constant time, as it performs a fixed number of operations. constant space, as it only uses a constant amount of memory.
    */
 
   /**
-   * Time Complexity: O(1) - constant time, as it performs a fixed number of operations.
-   * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * 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.
@@ -227,13 +228,14 @@ export class AVLTree<
   }
 
   /**
-   * Time Complexity: O(1) - constant time, as it performs a fixed number of operations.
-   * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   * constant time, as it performs a fixed number of operations. constant space, as it only uses a constant amount of memory.
    */
 
   /**
-   * Time Complexity: O(1) - constant time, as it performs a fixed number of operations.
-   * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * The function updates the height of a node in a binary tree based on the heights of its left and
    * right children.
@@ -249,20 +251,22 @@ export class AVLTree<
   }
 
   /**
-   * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The method traverses the path from the inserted node to the root.
-   * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   * logarithmic time, where "n" is the number of nodes in the tree. The method traverses the path from the inserted node to the root. constant space, as it doesn't use additional data structures that scale with input size.
    */
 
   /**
-   * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The method traverses the path from the inserted node to the root.
-   * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    *
    * 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.
    */
-  protected _balancePath(node: N): void {
+  protected _balancePath(node: KeyOrNodeOrEntry<K, V, N>): void {
+    node = this.ensureNode(node);
     const path = this.getPathToRoot(node, false); // first O(log n) + O(log n)
     for (let i = 0; i < path.length; i++) {
       // second O(log n)
@@ -302,13 +306,14 @@ export class AVLTree<
   }
 
   /**
-   * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-   * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   * constant time, as these methods perform a fixed number of operations. constant space, as they only use a constant amount of memory.
    */
 
   /**
-   * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-   * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * The function `_balanceLL` performs a left-left rotation to balance a binary tree.
    * @param {N} A - A is a node in a binary tree.
@@ -340,13 +345,13 @@ export class AVLTree<
   }
 
   /**
-   * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-   * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-   * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * The `_balanceLR` function performs a left-right rotation to balance a binary tree.
    * @param {N} A - A is a node in a binary tree.
@@ -396,13 +401,13 @@ export class AVLTree<
   }
 
   /**
-   * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-   * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-   * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * The function `_balanceRR` performs a right-right rotation to balance a binary tree.
    * @param {N} A - A is a node in a binary tree.
@@ -439,13 +444,13 @@ export class AVLTree<
   }
 
   /**
-   * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-   * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(1) - constant time, as these methods perform a fixed number of operations.
-   * Space Complexity: O(1) - constant space, as they only use a constant amount of memory.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * The function `_balanceRL` performs a right-left rotation to balance a binary tree.
    * @param {N} A - A is a node in a binary tree.