heap-typed 1.47.6 → 1.47.7

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

@@ -24,20 +24,17 @@ 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 {
-    /**
-     * The constructor function for a TreeMultimap class in TypeScript, which extends another class and sets an option to
-     * merge duplicated values.
-     * @param {TreeMultimapOptions} [options] - An optional object that contains additional configuration options for the
-     * TreeMultimap.
-     */
     constructor(elements, options) {
         super([], options);
         this._count = 0;
         if (elements)
-            this.init(elements);
+            this.addMany(elements);
     }
+    // TODO the _count is not accurate after nodes count modified
     get count() {
-        return this._count;
+        let sum = 0;
+        this.subTreeTraverse(node => sum += node.count);
+        return sum;
     }
     /**
      * The function creates a new BSTNode with the given key, value, and count.
@@ -54,131 +51,68 @@ class TreeMultimap extends avl_tree_1.AVLTree {
     createTree(options) {
         return new TreeMultimap([], Object.assign({ iterationType: this.iterationType, comparator: this.comparator }, options));
     }
+    /**
+     * 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.
+     */
     /**
      * 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 `add` function adds a new node to the tree multimap, updating the count if the key already
-     * exists, and balances the tree if necessary.
-     * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
-     * following types:
-     * @param {V} [value] - The `value` parameter represents the value associated with the key that is
-     * being added to the tree. It is an optional parameter, so it can be omitted if not needed.
+     * The `add` function overrides the base class `add` function to add a new node to the tree multimap
+     * and update the count.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
      * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
-     * times the key-value pair should be added to the multimap. If not provided, the default value is 1.
-     * @returns a node (`N`) or `undefined`.
+     * times the key or node or entry should be added to the multimap. If not provided, the default value
+     * is 1.
+     * @returns either a node (`N`) or `undefined`.
      */
-    add(keyOrNode, value, count = 1) {
-        if (keyOrNode === null)
-            return undefined;
-        let inserted = undefined, newNode;
-        if (keyOrNode instanceof TreeMultimapNode) {
-            newNode = this.createNode(keyOrNode.key, keyOrNode.value, keyOrNode.count);
+    add(keyOrNodeOrEntry, count = 1) {
+        let newNode;
+        if (keyOrNodeOrEntry === undefined || keyOrNodeOrEntry === null) {
+            return;
         }
-        else if (keyOrNode === undefined) {
-            newNode = undefined;
+        else if (keyOrNodeOrEntry instanceof TreeMultimapNode) {
+            newNode = keyOrNodeOrEntry;
         }
-        else {
-            newNode = this.createNode(keyOrNode, value, count);
+        else if (this.isNodeKey(keyOrNodeOrEntry)) {
+            newNode = this.createNode(keyOrNodeOrEntry, undefined, count);
         }
-        if (!this.root) {
-            this._setRoot(newNode);
-            this._size = this.size + 1;
-            if (newNode)
-                this._count += newNode.count;
-            inserted = this.root;
+        else if (this.isEntry(keyOrNodeOrEntry)) {
+            const [key, value] = keyOrNodeOrEntry;
+            if (key === undefined || key === null) {
+                return;
+            }
+            else {
+                newNode = this.createNode(key, value, count);
+            }
         }
         else {
-            let cur = this.root;
-            let traversing = true;
-            while (traversing) {
-                if (cur) {
-                    if (newNode) {
-                        if (this._compare(cur.key, newNode.key) === types_1.CP.eq) {
-                            cur.value = newNode.value;
-                            cur.count += newNode.count;
-                            this._count += newNode.count;
-                            traversing = false;
-                            inserted = cur;
-                        }
-                        else if (this._compare(cur.key, newNode.key) === types_1.CP.gt) {
-                            // Traverse left of the node
-                            if (cur.left === undefined) {
-                                //Add to the left of the current node
-                                cur.left = newNode;
-                                this._size = this.size + 1;
-                                this._count += newNode.count;
-                                traversing = false;
-                                inserted = cur.left;
-                            }
-                            else {
-                                //Traverse the left of the current node
-                                if (cur.left)
-                                    cur = cur.left;
-                            }
-                        }
-                        else if (this._compare(cur.key, newNode.key) === types_1.CP.lt) {
-                            // Traverse right of the node
-                            if (cur.right === undefined) {
-                                //Add to the right of the current node
-                                cur.right = newNode;
-                                this._size = this.size + 1;
-                                this._count += newNode.count;
-                                traversing = false;
-                                inserted = cur.right;
-                            }
-                            else {
-                                //Traverse the left of the current node
-                                if (cur.right)
-                                    cur = cur.right;
-                            }
-                        }
-                    }
-                    else {
-                        // TODO may need to support undefined inserted
-                    }
-                }
-                else {
-                    traversing = false;
-                }
-            }
+            return;
+        }
+        const orgNodeCount = (newNode === null || newNode === void 0 ? void 0 : newNode.count) || 0;
+        const inserted = super.add(newNode);
+        if (inserted) {
+            this._count += orgNodeCount;
         }
-        if (inserted)
-            this._balancePath(inserted);
         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 (AVLTree) has logarithmic time complexity.
+     * 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) - 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.
+     * 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.
      *
-     * The function `addMany` takes an array of keys or nodes and adds them to the TreeMultimap,
-     * returning an array of the inserted nodes.
-     * @param {(BTNKey | N | undefined)[]} keysOrNodes - An array of keys or nodes. Each element can be
-     * of type BTNKey, N, or undefined.
-     * @param {V[]} [data] - The `data` parameter is an optional array of values that correspond to the
-     * keys or nodes being added. It is used to associate data with each key or node being added to the
-     * TreeMultimap. If provided, the length of the `data` array should be the same as the length of the
-     * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
+     * The function overrides the addMany method to add multiple keys, nodes, or entries to a data
+     * structure.
+     * @param keysOrNodesOrEntries - The parameter `keysOrNodesOrEntries` is an iterable that can contain
+     * either keys, nodes, or entries.
+     * @returns The method is returning an array of type `N | undefined`.
      */
-    addMany(keysOrNodes, data) {
-        const inserted = [];
-        for (let i = 0; i < keysOrNodes.length; i++) {
-            const keyOrNode = keysOrNodes[i];
-            if (keyOrNode instanceof TreeMultimapNode) {
-                inserted.push(this.add(keyOrNode.key, keyOrNode.value, keyOrNode.count));
-                continue;
-            }
-            if (keyOrNode === undefined) {
-                inserted.push(this.add(NaN, undefined, 0));
-                continue;
-            }
-            inserted.push(this.add(keyOrNode, data === null || data === void 0 ? void 0 : data[i], 1));
-        }
-        return inserted;
+    addMany(keysOrNodesOrEntries) {
+        return super.addMany(keysOrNodesOrEntries);
     }
     /**
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
@@ -206,7 +140,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
                     return;
                 const m = l + Math.floor((r - l) / 2);
                 const midNode = sorted[m];
-                this.add(midNode.key, midNode.value, midNode.count);
+                this.add([midNode.key, midNode.value], midNode.count);
                 buildBalanceBST(l, m - 1);
                 buildBalanceBST(m + 1, r);
             };
@@ -222,7 +156,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
                         const midNode = sorted[m];
-                        this.add(midNode.key, midNode.value, midNode.count);
+                        this.add([midNode.key, midNode.value], midNode.count);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
                     }
@@ -289,7 +223,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
                 const leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : undefined;
                 if (leftSubTreeRightMost) {
                     const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
-                    orgCurrent = this._swap(curr, leftSubTreeRightMost);
+                    orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
                     if (parentOfLeftSubTreeMax) {
                         if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost) {
                             parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
@@ -323,23 +257,6 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         super.clear();
         this._count = 0;
     }
-    /**
-     * 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.
-     */
-    init(elements) {
-        if (elements) {
-            for (const entryOrKey of elements) {
-                if (Array.isArray(entryOrKey)) {
-                    const [key, value] = entryOrKey;
-                    this.add(key, value);
-                }
-                else {
-                    this.add(entryOrKey);
-                }
-            }
-        }
-    }
     /**
      * 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.
@@ -356,7 +273,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * added, or `undefined` if no node was added.
      */
     _addTo(newNode, parent) {
-        parent = this.ensureNotKey(parent);
+        parent = this.ensureNode(parent);
         if (parent) {
             if (parent.left === undefined) {
                 parent.left = newNode;
@@ -383,7 +300,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         }
     }
     /**
-     * The `_swap` function swaps the key, value, count, and height properties between two nodes.
+     * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
      * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node from
      * which the values will be swapped. It can be of type `BTNKey`, `N`, or `undefined`.
      * @param {BTNKey | N | undefined} destNode - The `destNode` parameter represents the destination
@@ -391,9 +308,9 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
      */
-    _swap(srcNode, destNode) {
-        srcNode = this.ensureNotKey(srcNode);
-        destNode = this.ensureNotKey(destNode);
+    _swapProperties(srcNode, destNode) {
+        srcNode = this.ensureNode(srcNode);
+        destNode = this.ensureNode(destNode);
         if (srcNode && destNode) {
             const { key, value, count, height } = destNode;
             const tempNode = this.createNode(key, value, count);
@@ -412,5 +329,9 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         }
         return undefined;
     }
+    _replaceNode(oldNode, newNode) {
+        newNode.count = oldNode.count + newNode.count;
+        return super._replaceNode(oldNode, newNode);
+    }
 }
 exports.TreeMultimap = TreeMultimap;

package/dist/data-structures/hash/hash-map.d.ts

@@ -14,12 +14,7 @@ export declare class HashMap<K = any, V = any> {
     protected readonly _sentinel: HashMapLinkedNode<K, V | undefined>;
     protected _hashFn: (key: K) => string;
     protected _objHashFn: (key: K) => object;
-    /**
-     * The constructor initializes a HashMapLinkedNode with an optional iterable of key-value pairs.
-     * @param options - The `options` parameter is an object that contains the `elements` property. The
-     * `elements` property is an iterable that contains key-value pairs represented as arrays `[K, V]`.
-     */
-    constructor(options?: HashMapOptions<K, V>);
+    constructor(elements?: Iterable<[K, V]>, options?: HashMapOptions<K>);
     protected _size: number;
     get size(): number;
     /**
@@ -172,6 +167,7 @@ export declare class HashMap<K = any, V = any> {
      * The above function is an iterator that yields key-value pairs from a linked list.
      */
     [Symbol.iterator](): Generator<[K, V], void, unknown>;
+    print(): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

package/dist/data-structures/hash/hash-map.js

@@ -10,13 +10,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HashMap = void 0;
 const utils_1 = require("../../utils");
 class HashMap {
-    /**
-     * The constructor initializes a HashMapLinkedNode with an optional iterable of key-value pairs.
-     * @param options - The `options` parameter is an object that contains the `elements` property. The
-     * `elements` property is an iterable that contains key-value pairs represented as arrays `[K, V]`.
-     */
-    constructor(options = {
-        elements: [],
+    constructor(elements, options = {
         hashFn: (key) => String(key),
         objHashFn: (key) => key
     }) {
@@ -25,7 +19,7 @@ class HashMap {
         this._size = 0;
         this._sentinel = {};
         this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
-        const { elements, hashFn, objHashFn } = options;
+        const { hashFn, objHashFn } = options;
         this._hashFn = hashFn;
         this._objHashFn = objHashFn;
         if (elements) {
@@ -347,6 +341,9 @@ class HashMap {
             node = node.next;
         }
     }
+    print() {
+        console.log([...this]);
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -20,6 +20,8 @@ export declare class TrieNode {
  */
 export declare class Trie {
     constructor(words?: string[], caseSensitive?: boolean);
+    protected _size: number;
+    get size(): number;
     protected _caseSensitive: boolean;
     get caseSensitive(): boolean;
     protected _root: TrieNode;
@@ -145,6 +147,7 @@ export declare class Trie {
     filter(predicate: (word: string, index: number, trie: this) => boolean): string[];
     map(callback: (word: string, index: number, trie: this) => string): Trie;
     reduce<T>(callback: (accumulator: T, word: string, index: number, trie: this) => T, initialValue: T): T;
+    print(): void;
     /**
      * Time Complexity: O(M), where M is the length of the input string.
      * Space Complexity: O(1) - Constant space.

package/dist/data-structures/trie/trie.js

@@ -27,12 +27,16 @@ class Trie {
     constructor(words, caseSensitive = true) {
         this._root = new TrieNode('');
         this._caseSensitive = caseSensitive;
+        this._size = 0;
         if (words) {
-            for (const i of words) {
-                this.add(i);
+            for (const word of words) {
+                this.add(word);
             }
         }
     }
+    get size() {
+        return this._size;
+    }
     get caseSensitive() {
         return this._caseSensitive;
     }
@@ -54,6 +58,7 @@ class Trie {
     add(word) {
         word = this._caseProcess(word);
         let cur = this.root;
+        let isNewWord = false;
         for (const c of word) {
             let nodeC = cur.children.get(c);
             if (!nodeC) {
@@ -62,8 +67,12 @@ class Trie {
             }
             cur = nodeC;
         }
-        cur.isEnd = true;
-        return true;
+        if (!cur.isEnd) {
+            isNewWord = true;
+            cur.isEnd = true;
+            this._size++;
+        }
+        return isNewWord;
     }
     /**
      * Time Complexity: O(M), where M is the length of the input word.
@@ -130,6 +139,9 @@ class Trie {
             return false;
         };
         dfs(this.root, 0);
+        if (isDeleted) {
+            this._size--;
+        }
         return isDeleted;
     }
     /**
@@ -352,6 +364,9 @@ class Trie {
         }
         return accumulator;
     }
+    print() {
+        console.log([...this]);
+    }
     /**
      * Time Complexity: O(M), where M is the length of the input string.
      * Space Complexity: O(1) - Constant space.

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

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

package/dist/types/common.d.ts

@@ -19,4 +19,9 @@ export type BinaryTreePrintOptions = {
     isShowNull?: boolean;
     isShowRedBlackNIL?: boolean;
 };
-export type IterableEntriesOrKeys<T> = Iterable<[BTNKey, T | undefined] | BTNKey>;
+export type BTNodeEntry<T> = [BTNKey | null | undefined, T | undefined];
+export type BTNodeKeyOrNode<N> = BTNKey | null | undefined | N;
+export type BTNodeExemplar<T, N> = BTNodeEntry<T> | BTNodeKeyOrNode<N>;
+export type BTNodePureExemplar<T, N> = [BTNKey, T | undefined] | BTNodePureKeyOrNode<N>;
+export type BTNodePureKeyOrNode<N> = BTNKey | N;
+export type BSTNodeKeyOrNode<N> = BTNKey | undefined | N;

package/dist/types/data-structures/hash/hash-map.d.ts

@@ -4,8 +4,7 @@ export type HashMapLinkedNode<K, V> = {
     next: HashMapLinkedNode<K, V>;
     prev: HashMapLinkedNode<K, V>;
 };
-export type HashMapOptions<K, V> = {
-    elements: Iterable<[K, V]>;
+export type HashMapOptions<K> = {
     hashFn: (key: K) => string;
     objHashFn: (key: K) => object;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heap-typed",
-  "version": "1.47.6",
+  "version": "1.47.7",
   "description": "Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -131,6 +131,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.47.6"
+    "data-structure-typed": "^1.47.7"
   }
 }

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

@@ -6,8 +6,16 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BiTreeDeleteResult, BTNKey } from '../../types';
-import { BTNCallback, IterableEntriesOrKeys } from '../../types';
+import type {
+  AVLTreeNested,
+  AVLTreeNodeNested,
+  AVLTreeOptions,
+  BiTreeDeleteResult,
+  BSTNodeKeyOrNode,
+  BTNKey,
+  BTNodeExemplar
+} from '../../types';
+import { BTNCallback } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 
 export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNested<V>> extends BSTNode<V, N> {
@@ -19,19 +27,32 @@ export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNeste
   }
 }
 
+/**
+ * 1. Height-Balanced: Each node's left and right subtrees differ in height by no more than one.
+ * 2. Automatic Rebalancing: AVL trees rebalance themselves automatically during insertions and deletions.
+ * 3. Rotations for Balancing: Utilizes rotations (single or double) to maintain balance after updates.
+ * 4. Order Preservation: Maintains the binary search tree property where left child values are less than the parent, and right child values are greater.
+ * 5. Efficient Lookups: Offers O(log n) search time, where 'n' is the number of nodes, due to its balanced nature.
+ * 6. Complex Insertions and Deletions: Due to rebalancing, these operations are more complex than in a regular BST.
+ * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
+ * 8. Memory Overhead: Stores balance factors (or heights) at each node, leading to slightly higher memory usage compared to a regular BST.
+ */
 export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTreeNodeNested<V>>, TREE extends AVLTree<V, N, TREE> = AVLTree<V, N, AVLTreeNested<V, N>>>
   extends BST<V, N, TREE>
   implements IBinaryTree<V, N, TREE> {
 
   /**
-   * This is a constructor function for an AVL tree data structure in TypeScript.
-   * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
-   * constructor of the AVLTree class. It allows you to customize the behavior of the AVL tree by providing different
-   * options.
+   * The constructor function initializes an AVLTree object with optional elements and options.
+   * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<V, N>`
+   * objects. It represents a collection of elements 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?: IterableEntriesOrKeys<V>, options?: Partial<AVLTreeOptions>) {
+  constructor(elements?: Iterable<BTNodeExemplar<V, N>>, options?: Partial<AVLTreeOptions>) {
     super([], options);
-    if (elements) this.init(elements);
+    if (elements) super.addMany(elements);
   }
 
   /**
@@ -47,6 +68,13 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
     return new AVLTreeNode<V, N>(key, value) as N;
   }
 
+  /**
+   * The function creates a new AVL tree with the specified options and returns it.
+   * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be
+   * passed to the `createTree` function. It is used to customize the behavior of the AVL tree that is
+   * being created.
+   * @returns a new AVLTree object.
+   */
   override createTree(options?: AVLTreeOptions): TREE {
     return new AVLTree<V, N, TREE>([], {
       iterationType: this.iterationType,
@@ -54,21 +82,24 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
     }) as TREE;
   }
 
+  /**
+   * 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) - 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.
    *
-   * The function overrides the add method of a class, adds a key-value pair to a data structure, and
-   * balances the structure if necessary.
-   * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be of type
-   * `BTNKey`, `N`, `null`, or `undefined`.
-   * @param {V} [value] - The `value` parameter is the value associated with the key that is being
-   * added to the binary search tree.
-   * @returns The method is returning either a node (N) or undefined.
+   * The function overrides the add method of a binary tree node and balances the tree after inserting
+   * a new node.
+   * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be either a key, a node, or an
+   * entry.
+   * @returns The method is returning either the inserted node or `undefined`.
    */
-  override add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | undefined {
-    if (keyOrNode === null) return undefined;
-    const inserted = super.add(keyOrNode, value);
+  override add(keyOrNodeOrEntry: BTNodeExemplar<V, N>): N | undefined {
+    if (keyOrNodeOrEntry === null) return undefined;
+    const inserted = super.add(keyOrNodeOrEntry);
     if (inserted) this._balancePath(inserted);
     return inserted;
   }
@@ -107,26 +138,9 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
     return deletedResults;
   }
 
-  /**
-   * 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.
-   */
-
-  init(elements: IterableEntriesOrKeys<V>): void {
-    if (elements) {
-      for (const entryOrKey of elements) {
-        if (Array.isArray(entryOrKey)) {
-          const [key, value] = entryOrKey;
-          this.add(key, value);
-        } else {
-          this.add(entryOrKey);
-        }
-      }
-    }
-  }
 
   /**
-   * The `_swap` function swaps the key, value, and height properties between two nodes in a binary
+   * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a binary
    * tree.
    * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node that
    * needs to be swapped with the destination node. It can be of type `BTNKey`, `N`, or `undefined`.
@@ -135,9 +149,9 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
    * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
    * if either `srcNode` or `destNode` is undefined.
    */
-  protected override _swap(srcNode: BTNKey | N | undefined, destNode: BTNKey | N | undefined): N | undefined {
-    srcNode = this.ensureNotKey(srcNode);
-    destNode = this.ensureNotKey(destNode);
+  protected override _swapProperties(srcNode: BSTNodeKeyOrNode<N>, destNode: BSTNodeKeyOrNode<N>): N | undefined {
+    srcNode = this.ensureNode(srcNode);
+    destNode = this.ensureNode(destNode);
 
     if (srcNode && destNode) {
       const { key, value, height } = destNode;
@@ -450,4 +464,10 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
     B && this._updateHeight(B);
     C && this._updateHeight(C);
   }
+
+  protected _replaceNode(oldNode: N, newNode: N): N {
+    newNode.height = oldNode.height;
+
+    return super._replaceNode(oldNode, newNode)
+  }
 }