data-structure-typed 1.49.5 → 1.49.7

package/dist/cjs/types/data-structures/hash/index.js

@@ -15,5 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./hash-map"), exports);
-__exportStar(require("./hash-table"), exports);
 //# sourceMappingURL=index.js.map

package/dist/cjs/types/data-structures/hash/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/types/data-structures/hash/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA2B;AAC3B,+CAA6B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/types/data-structures/hash/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA2B"}

package/dist/cjs/types/data-structures/heap/heap.d.ts

@@ -1,4 +1,4 @@
 import { Comparator } from '../../common';
 export type HeapOptions<T> = {
-    comparator: Comparator<T>;
+    comparator?: Comparator<T>;
 };

package/dist/cjs/types/data-structures/linked-list/index.d.ts

@@ -1,2 +1,3 @@
 export * from './singly-linked-list';
 export * from './doubly-linked-list';
+export * from './skip-linked-list';

package/dist/cjs/types/data-structures/linked-list/index.js

@@ -16,4 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./singly-linked-list"), exports);
 __exportStar(require("./doubly-linked-list"), exports);
+__exportStar(require("./skip-linked-list"), exports);
 //# sourceMappingURL=index.js.map

package/dist/cjs/types/data-structures/linked-list/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/types/data-structures/linked-list/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,uDAAqC;AACrC,uDAAqC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/types/data-structures/linked-list/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,uDAAqC;AACrC,uDAAqC;AACrC,qDAAmC"}

package/dist/cjs/types/data-structures/linked-list/skip-linked-list.d.ts

@@ -1 +1,4 @@
-export {};
+export type SkipLinkedListOptions = {
+    maxLevel?: number;
+    probability?: number;
+};

package/dist/cjs/types/data-structures/matrix/index.d.ts

@@ -1 +1,2 @@
 export * from './navigator';
+export * from './matrix';

package/dist/cjs/types/data-structures/matrix/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./navigator"), exports);
+__exportStar(require("./matrix"), exports);
 //# sourceMappingURL=index.js.map

package/dist/cjs/types/data-structures/matrix/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/types/data-structures/matrix/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAA4B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/types/data-structures/matrix/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAA4B;AAC5B,2CAAyB"}

package/dist/cjs/types/data-structures/matrix/matrix.d.ts

@@ -1 +1,7 @@
-export {};
+export type MatrixOptions = {
+    rows?: number;
+    cols?: number;
+    addFn?: (a: number, b: number) => any;
+    subtractFn?: (a: number, b: number) => any;
+    multiplyFn?: (a: number, b: number) => any;
+};

package/dist/cjs/types/data-structures/queue/deque.d.ts

@@ -1 +1,3 @@
-export {};
+export type DequeOptions = {
+    bucketSize?: number;
+};

package/dist/cjs/types/data-structures/trie/trie.d.ts

@@ -1 +1,3 @@
-export {};
+export type TrieOptions = {
+    caseSensitive?: boolean;
+};

package/dist/mjs/data-structures/binary-tree/avl-tree.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, BTNExemplar, BTNKeyOrNode } from '../../types';
+import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 export declare class AVLTreeNode<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeNodeNested<K, V>> extends BSTNode<K, V, N> {
     height: number;
@@ -23,15 +23,15 @@ export declare class AVLTreeNode<K = any, V = any, N extends AVLTreeNode<K, V, N
  */
 export declare class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>, TREE extends AVLTree<K, V, N, TREE> = AVLTree<K, V, N, AVLTreeNested<K, V, N>>> 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 keysOrNodesOrEntries and options.
+     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` 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(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: AVLTreeOptions<K>);
     /**
      * The function creates a new AVL tree node with the specified key and value.
      * @param {K} key - The key parameter is the key value that will be associated with
@@ -51,25 +51,26 @@ export declare class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> =
      */
     createTree(options?: AVLTreeOptions<K>): TREE;
     /**
-     * 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.
      */
-    isNode(exemplar: BTNExemplar<K, V, N>): exemplar is N;
+    isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>): keyOrNodeOrEntry is N;
     /**
      * 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: BTNKeyOrNode<K, N>): potentialKey is K;
+    isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K;
     /**
-     * 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.
@@ -79,14 +80,14 @@ export declare class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> =
      * being added to the binary tree.
      * @returns The method is returning either the inserted node or undefined.
      */
-    add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V): N | undefined;
+    add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V): boolean;
     /**
-     * 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.
@@ -112,12 +113,13 @@ export declare class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> =
      */
     protected _swapProperties(srcNode: BSTNKeyOrNode<K, N>, destNode: BSTNKeyOrNode<K, N>): N | undefined;
     /**
-     * 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.
@@ -126,12 +128,13 @@ export declare class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> =
      */
     protected _balanceFactor(node: N): number;
     /**
-     * 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.
@@ -139,62 +142,64 @@ export declare class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> =
      */
     protected _updateHeight(node: N): void;
     /**
-     * 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;
     /**
-     * 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.
      */
     protected _balanceLL(A: N): void;
     /**
-     * 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.
      */
     protected _balanceLR(A: N): void;
     /**
-     * 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.
      */
     protected _balanceRR(A: N): void;
     /**
-     * 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.

package/dist/mjs/data-structures/binary-tree/avl-tree.js

@@ -24,18 +24,18 @@ export class AVLTreeNode extends BSTNode {
  */
 export class AVLTree extends BST {
     /**
-     * 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 keysOrNodesOrEntries and options.
+     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` 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, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
         super([], options);
-        if (elements)
-            super.addMany(elements);
+        if (keysOrNodesOrEntries)
+            super.addMany(keysOrNodesOrEntries);
     }
     /**
      * The function creates a new AVL tree node with the specified key and value.
@@ -64,12 +64,12 @@ export class AVLTree extends BST {
         });
     }
     /**
-     * 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.
      */
-    isNode(exemplar) {
-        return exemplar instanceof AVLTreeNode;
+    isNode(keyOrNodeOrEntry) {
+        return keyOrNodeOrEntry instanceof AVLTreeNode;
     }
     /**
      * The function "isNotNodeInstance" checks if a potential key is a K.
@@ -81,12 +81,13 @@ export class AVLTree extends BST {
         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.
@@ -98,19 +99,19 @@ export class AVLTree extends BST {
      */
     add(keyOrNodeOrEntry, value) {
         if (keyOrNodeOrEntry === null)
-            return undefined;
+            return false;
         const inserted = super.add(keyOrNodeOrEntry, value);
         if (inserted)
-            this._balancePath(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.
@@ -164,12 +165,13 @@ export class AVLTree extends BST {
         return undefined;
     }
     /**
-     * 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.
@@ -187,12 +189,13 @@ export class AVLTree extends BST {
             return node.right.height - node.left.height;
     }
     /**
-     * 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.
@@ -211,12 +214,13 @@ export class AVLTree extends BST {
             node.height = 1 + Math.max(node.right.height, node.left.height);
     }
     /**
-     * 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.
@@ -224,6 +228,7 @@ export class AVLTree extends BST {
      * AVL tree that needs to be balanced.
      */
     _balancePath(node) {
+        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)
@@ -263,12 +268,13 @@ export class AVLTree extends BST {
         }
     }
     /**
-     * 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.
@@ -304,12 +310,12 @@ export class AVLTree extends BST {
             this._updateHeight(B);
     }
     /**
-     * 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.
@@ -360,12 +366,12 @@ export class AVLTree extends BST {
         C && this._updateHeight(C);
     }
     /**
-     * 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.
@@ -402,12 +408,12 @@ export class AVLTree extends BST {
         B && this._updateHeight(B);
     }
     /**
-     * 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.