data-structure-typed 2.6.0 → 2.6.1

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

@@ -10,7 +10,8 @@ import type {
   BinaryTreeDeleteResult,
   BinaryTreeOptions,
   BinaryTreePrintOptions,
-  BTNEntry, BTNRep,
+  BTNEntry,
+  BTNRep,
   DFSOrderPattern,
   DFSStackItem,
   EntryCallback,
@@ -272,6 +273,10 @@ export class BinaryTree<K = any, V = any, R = any>
   implements IBinaryTree<K, V, R>
 {
   iterationType: IterationType = 'ITERATIVE';
+  protected readonly _isMapMode: boolean = true;
+  protected readonly _isDuplicate: boolean = false;
+  protected readonly _NIL = new BinaryTreeNode<K, V>(NaN as K);
+  protected readonly _toEntryFn?: ToEntryFn<K, V, R>;
 
   /**
    * Creates an instance of BinaryTree.
@@ -299,7 +304,8 @@ export class BinaryTree<K = any, V = any, R = any>
     if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
 
-  protected readonly _isMapMode: boolean = true;
+  // Map mode acceleration store:
+  // - isMapMode=false: unused
 
   /**
    * Gets whether the tree is in Map mode.
@@ -311,8 +317,6 @@ export class BinaryTree<K = any, V = any, R = any>
     return this._isMapMode;
   }
 
-  protected readonly _isDuplicate: boolean = false;
-
   /**
    * Gets whether the tree allows duplicate keys.
    * @remarks Time O(1)
@@ -323,8 +327,6 @@ export class BinaryTree<K = any, V = any, R = any>
     return this._isDuplicate;
   }
 
-  // Map mode acceleration store:
-  // - isMapMode=false: unused
   // - isMapMode=true: key -> node reference (O(1) has/getNode + fast get)
   protected _store = new Map<K, BinaryTreeNode<K, V>>();
 
@@ -362,8 +364,6 @@ export class BinaryTree<K = any, V = any, R = any>
     return this._size;
   }
 
-  protected readonly _NIL = new BinaryTreeNode<K, V>(NaN as K);
-
   /**
    * Gets the sentinel NIL node (used in self-balancing trees like Red-Black Tree).
    * @remarks Time O(1)
@@ -374,8 +374,6 @@ export class BinaryTree<K = any, V = any, R = any>
     return this._NIL;
   }
 
-  protected readonly _toEntryFn?: ToEntryFn<K, V, R>;
-
   /**
    * Gets the function used to convert raw data objects (R) into [key, value] entries.
    * @remarks Time O(1)
@@ -386,6 +384,39 @@ export class BinaryTree<K = any, V = any, R = any>
     return this._toEntryFn;
   }
 
+  protected static _buildNodeDisplay(line: string, width: number, left: NodeDisplayLayout, right: NodeDisplayLayout) {
+    const [leftLines, leftWidth, leftHeight, leftMiddle] = left;
+    const [rightLines, rightWidth, rightHeight, rightMiddle] = right;
+    const firstLine =
+      ' '.repeat(Math.max(0, leftMiddle + 1)) +
+      '_'.repeat(Math.max(0, leftWidth - leftMiddle - 1)) +
+      line +
+      '_'.repeat(Math.max(0, rightMiddle)) +
+      ' '.repeat(Math.max(0, rightWidth - rightMiddle));
+
+    const secondLine =
+      (leftHeight > 0 ? ' '.repeat(leftMiddle) + '/' + ' '.repeat(leftWidth - leftMiddle - 1) : ' '.repeat(leftWidth)) +
+      ' '.repeat(width) +
+      (rightHeight > 0
+        ? ' '.repeat(rightMiddle) + '\\' + ' '.repeat(rightWidth - rightMiddle - 1)
+        : ' '.repeat(rightWidth));
+
+    const mergedLines = [firstLine, secondLine];
+
+    for (let i = 0; i < Math.max(leftHeight, rightHeight); i++) {
+      const leftLine = i < leftHeight ? leftLines[i] : ' '.repeat(leftWidth);
+      const rightLine = i < rightHeight ? rightLines[i] : ' '.repeat(rightWidth);
+      mergedLines.push(leftLine + ' '.repeat(width) + rightLine);
+    }
+
+    return <NodeDisplayLayout>[
+      mergedLines,
+      leftWidth + width + rightWidth,
+      Math.max(leftHeight, rightHeight) + 2,
+      leftWidth + Math.floor(width / 2)
+    ];
+  }
+
   /**
    * (Protected) Creates a new node.
    * @remarks Time O(1), Space O(1)
@@ -566,55 +597,16 @@ export class BinaryTree<K = any, V = any, R = any>
    *
    * @param keyNodeOrEntry - The key, node, or entry to add.
    * @returns True if the addition was successful, false otherwise.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Add a single node
- *  const tree = new BinaryTree<number>();
- *     tree.add(1);
- *     tree.add(2);
- *     tree.add(3);
- *     console.log(tree.size); // 3;
- *     console.log(tree.has(1)); // true;
-   */
-  add(
-    keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
-  ): boolean {
+   * @example
+   * // Add a single node
+   *  const tree = new BinaryTree<number>();
+   *     tree.add(1);
+   *     tree.add(2);
+   *     tree.add(3);
+   *     console.log(tree.size); // 3;
+   *     console.log(tree.has(1)); // true;
+   */
+  add(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): boolean {
     return this.set(keyNodeOrEntry);
   }
 
@@ -625,77 +617,34 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param keyNodeOrEntry - The key, node, or entry to set or update.
    * @param [value] - The value, if providing just a key.
    * @returns True if the addition was successful, false otherwise.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // basic BinaryTree creation and insertion
- *  // Create a BinaryTree with entries
- *     const entries: [number, string][] = [
- *       [6, 'six'],
- *       [1, 'one'],
- *       [2, 'two'],
- *       [7, 'seven'],
- *       [5, 'five'],
- *       [3, 'three'],
- *       [4, 'four'],
- *       [9, 'nine'],
- *       [8, 'eight']
- *     ];
- *
- *     const tree = new BinaryTree(entries);
- *
- *     // Verify size
- *     console.log(tree.size); // 9;
- *
- *     // Add new element
- *     tree.set(10, 'ten');
- *     console.log(tree.size); // 10;
+   * @example
+   * // basic BinaryTree creation and insertion
+   *  // Create a BinaryTree with entries
+   *     const entries: [number, string][] = [
+   *       [6, 'six'],
+   *       [1, 'one'],
+   *       [2, 'two'],
+   *       [7, 'seven'],
+   *       [5, 'five'],
+   *       [3, 'three'],
+   *       [4, 'four'],
+   *       [9, 'nine'],
+   *       [8, 'eight']
+   *     ];
+   *
+   *     const tree = new BinaryTree(entries);
+   *
+   *     // Verify size
+   *     console.log(tree.size); // 9;
+   *
+   *     // Add new element
+   *     tree.set(10, 'ten');
+   *     console.log(tree.size); // 10;
    */
   set(
     keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V
   ): boolean {
-
     const [newNode] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (newNode === undefined) return false;
 
@@ -753,51 +702,11 @@ export class BinaryTree<K = any, V = any, R = any>
    *
    * @param keysNodesEntriesOrRaws - An iterable of items to set.
    * @returns An array of booleans indicating the success of each individual `set` operation.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Bulk add
- *  const tree = new BinaryTree<number>();
- *     tree.addMany([1, 2, 3, 4, 5]);
- *     console.log(tree.size); // 5;
+   * @example
+   * // Bulk add
+   *  const tree = new BinaryTree<number>();
+   *     tree.addMany([1, 2, 3, 4, 5]);
+   *     console.log(tree.size); // 5;
    */
   addMany(
     keysNodesEntriesOrRaws: Iterable<
@@ -814,44 +723,15 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param keysNodesEntriesOrRaws - An iterable of items to set or update.
    * @param [values] - An optional parallel iterable of values.
    * @returns An array of booleans indicating the success of each individual `set` operation.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Set multiple entries
- *  const tree = new BinaryTree<number, string>();
- *     tree.setMany([[1, 'a'], [2, 'b'], [3, 'c']]);
- *     console.log(tree.size); // 3;
+   * @example
+   * // Set multiple entries
+   *  const tree = new BinaryTree<number, string>();
+   *     tree.setMany([
+   *       [1, 'a'],
+   *       [2, 'b'],
+   *       [3, 'c']
+   *     ]);
+   *     console.log(tree.size); // 3;
    */
   setMany(
     keysNodesEntriesOrRaws: Iterable<
@@ -887,172 +767,29 @@ export class BinaryTree<K = any, V = any, R = any>
    * @remarks Time O(N * M), same as `setMany`, where N is the size of `anotherTree` and M is the size of this tree. Space O(M) (from `set`).
    *
    * @param anotherTree - The tree to merge.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Combine trees
- *  const t1 = new BinaryTree<number>([1, 2]);
- *     const t2 = new BinaryTree<number>([3, 4]);
- *     t1.merge(t2);
- *     console.log(t1.size); // 4;
+   * @example
+   * // Combine trees
+   *  const t1 = new BinaryTree<number>([1, 2]);
+   *     const t2 = new BinaryTree<number>([3, 4]);
+   *     t1.merge(t2);
+   *     console.log(t1.size); // 4;
    */
   merge(anotherTree: BinaryTree<K, V, R>) {
     this.setMany(anotherTree, []);
   }
 
-  /**
-   * Deletes a node from the tree (internal, returns balancing metadata).
-   * @remarks Time O(N) — O(N) to find the node + O(H) for predecessor swap. Space O(1). BST/Red-Black Tree/AVL Tree subclasses override to O(log N).
-   * @internal Used by AVL/BST subclasses that need balancing metadata after deletion.
-   *
-   * @param keyNodeEntryRawOrPredicate - The node to delete.
-   * @returns An array containing deletion results with balancing metadata.
-   */
-  protected _deleteInternal(
-    keyNodeEntryRawOrPredicate: BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V> | null>
-  ): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[] {
-    const deletedResult: BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[] = [];
-    if (!this._root) return deletedResult;
-
-    const curr = this.getNode(keyNodeEntryRawOrPredicate);
-    if (!curr) return deletedResult;
-
-    const parent: BinaryTreeNode<K, V> | undefined = curr?.parent;
-    let needBalanced: BinaryTreeNode<K, V> | undefined;
-    let orgCurrent: BinaryTreeNode<K, V> | undefined = curr;
-
-    if (!curr.left && !curr.right && !parent) {
-      this._setRoot(undefined);
-    } else if (curr.left) {
-      const leftSubTreeRightMost = this.getRightMost(node => node, curr.left);
-      if (leftSubTreeRightMost) {
-        const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
-        orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
-
-        if (this._isMapMode) {
-          this._store.set(curr.key, curr);
-          this._store.set(leftSubTreeRightMost.key, leftSubTreeRightMost);
-        }
-
-        if (parentOfLeftSubTreeMax) {
-          if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
-            parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
-          else parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
-          needBalanced = parentOfLeftSubTreeMax;
-        }
-      }
-    } else if (parent) {
-      const { familyPosition: fp } = curr;
-      if (fp === 'LEFT' || fp === 'ROOT_LEFT') {
-        parent.left = curr.right;
-      } else if (fp === 'RIGHT' || fp === 'ROOT_RIGHT') {
-        parent.right = curr.right;
-      }
-      needBalanced = parent;
-    } else {
-      this._setRoot(curr.right);
-      curr.right = undefined;
-    }
-
-    this._size = this._size - 1;
-
-    deletedResult.push({ deleted: orgCurrent, needBalanced });
-    if (this._isMapMode && orgCurrent) this._store.delete(orgCurrent.key);
-    return deletedResult;
-  }
-
   /**
    * Deletes a node from the tree.
    * @remarks Time O(N) — O(N) to find the node + O(H) for predecessor swap. Space O(1). BST/Red-Black Tree/AVL Tree subclasses override to O(log N).
    *
    * @param keyNodeEntryRawOrPredicate - The node to delete.
    * @returns True if the node was found and deleted, false otherwise.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Remove a node
- *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
- *     tree.delete(3);
- *     console.log(tree.has(3)); // false;
- *     console.log(tree.size); // 4;
+   * @example
+   * // Remove a node
+   *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
+   *     tree.delete(3);
+   *     console.log(tree.has(3)); // false;
+   *     console.log(tree.size); // 4;
    */
   delete(
     keyNodeEntryRawOrPredicate: BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V> | null>
@@ -1060,46 +797,13 @@ export class BinaryTree<K = any, V = any, R = any>
     return this._deleteInternal(keyNodeEntryRawOrPredicate).length > 0;
   }
 
-    /**
+  /**
    * Search by predicate
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Search by predicate
- *  const tree = new BinaryTree<number>([5, 3, 7, 1, 9]);
- *     const found = tree.search(n => n!.key > 5, true);
- *     console.log(found.length); // >= 1;
+   * @example
+   * // Search by predicate
+   *  const tree = new BinaryTree<number>([5, 3, 7, 1, 9]);
+   *     const found = tree.search(n => n!.key > 5, true);
+   *     console.log(found.length); // >= 1;
    */
   search(
     keyNodeEntryOrPredicate:
@@ -1199,50 +903,11 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param [startNode=this._root] - The node to start the search from.
    * @param [iterationType=this.iterationType] - The traversal method.
    * @returns An array of matching nodes.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Get nodes by condition
- *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
- *     const nodes = tree.getNodes(node => node.key > 3);
- *     console.log(nodes.length); // 2;
+   * @example
+   * // Get nodes by condition
+   *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
+   *     const nodes = tree.getNodes(node => node.key > 3);
+   *     console.log(nodes.length); // 2;
    */
   getNodes(
     keyNodeEntryOrPredicate:
@@ -1280,50 +945,13 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param [startNode=this._root] - The node to start the search from.
    * @param [iterationType=this.iterationType] - The traversal method.
    * @returns The first matching node, or undefined if not found.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Get node by key
- *  const tree = new BinaryTree<number, string>([[1, 'root'], [2, 'child']]);
- *     console.log(tree.getNode(2)?.value); // 'child';
+   * @example
+   * // Get node by key
+   *  const tree = new BinaryTree<number, string>([
+   *       [1, 'root'],
+   *       [2, 'child']
+   *     ]);
+   *     console.log(tree.getNode(2)?.value); // 'child';
    */
   getNode(
     keyNodeEntryOrPredicate:
@@ -1354,53 +982,15 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param [startNode=this._root] - The node to start searching from (if not in Map mode).
    * @param [iterationType=this.iterationType] - The traversal method (if not in Map mode).
    * @returns The associated value, or undefined.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Retrieve value by key
- *  const tree = new BinaryTree<number, string>([[1, 'root'], [2, 'left'], [3, 'right']]);
- *     console.log(tree.get(2)); // 'left';
- *     console.log(tree.get(99)); // undefined;
+   * @example
+   * // Retrieve value by key
+   *  const tree = new BinaryTree<number, string>([
+   *       [1, 'root'],
+   *       [2, 'left'],
+   *       [3, 'right']
+   *     ]);
+   *     console.log(tree.get(2)); // 'left';
+   *     console.log(tree.get(99)); // undefined;
    */
   override get(
     keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
@@ -1423,76 +1013,34 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param [startNode] - The node to start the search from.
    * @param [iterationType] - The traversal method.
    * @returns True if a matching node exists, false otherwise.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // BinaryTree get and has operations
- *  const tree = new BinaryTree(
- *       [
- *         [5, 'five'],
- *         [3, 'three'],
- *         [7, 'seven'],
- *         [1, 'one'],
- *         [4, 'four'],
- *         [6, 'six'],
- *         [8, 'eight']
- *       ],
- *       { isMapMode: false }
- *     );
- *
- *     // Check if key exists
- *     console.log(tree.has(5)); // true;
- *     console.log(tree.has(10)); // false;
- *
- *     // Get value by key
- *     console.log(tree.get(3)); // 'three';
- *     console.log(tree.get(7)); // 'seven';
- *     console.log(tree.get(100)); // undefined;
- *
- *     // Get node structure
- *     const node = tree.getNode(5);
- *     console.log(node?.key); // 5;
- *     console.log(node?.value); // 'five';
+   * @example
+   * // BinaryTree get and has operations
+   *  const tree = new BinaryTree(
+   *       [
+   *         [5, 'five'],
+   *         [3, 'three'],
+   *         [7, 'seven'],
+   *         [1, 'one'],
+   *         [4, 'four'],
+   *         [6, 'six'],
+   *         [8, 'eight']
+   *       ],
+   *       { isMapMode: false }
+   *     );
+   *
+   *     // Check if key exists
+   *     console.log(tree.has(5)); // true;
+   *     console.log(tree.has(10)); // false;
+   *
+   *     // Get value by key
+   *     console.log(tree.get(3)); // 'three';
+   *     console.log(tree.get(7)); // 'seven';
+   *     console.log(tree.get(100)); // undefined;
+   *
+   *     // Get node structure
+   *     const node = tree.getNode(5);
+   *     console.log(node?.key); // 5;
+   *     console.log(node?.value); // 'five';
    */
   override has(
     keyNodeEntryOrPredicate?:
@@ -1530,51 +1078,11 @@ export class BinaryTree<K = any, V = any, R = any>
   /**
    * Clears the tree of all nodes and values.
    * @remarks Time O(N) if in Map mode (due to `_store.clear()`), O(1) otherwise. Space O(1)
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Remove all nodes
- *  const tree = new BinaryTree<number>([1, 2, 3]);
- *     tree.clear();
- *     console.log(tree.isEmpty()); // true;
+   * @example
+   * // Remove all nodes
+   *  const tree = new BinaryTree<number>([1, 2, 3]);
+   *     tree.clear();
+   *     console.log(tree.isEmpty()); // true;
    */
   clear() {
     this._clearNodes();
@@ -1586,49 +1094,9 @@ export class BinaryTree<K = any, V = any, R = any>
    * @remarks Time O(1), Space O(1)
    *
    * @returns True if the tree has no nodes, false otherwise.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Check empty
- *  console.log(new BinaryTree().isEmpty()); // true;
+   * @example
+   * // Check empty
+   *  console.log(new BinaryTree().isEmpty()); // true;
    */
   isEmpty(): boolean {
     return this._size === 0;
@@ -1654,51 +1122,11 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param [startNode=this._root] - The node to start checking from.
    * @param [iterationType=this.iterationType] - The traversal method.
    * @returns True if it's a valid BST, false otherwise.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Check BST property
- *  const tree = new BinaryTree<number>([1, 2, 3]);
- *     // BinaryTree doesn't guarantee BST order
- *     console.log(typeof tree.isBST()); // 'boolean';
+   * @example
+   * // Check BST property
+   *  const tree = new BinaryTree<number>([1, 2, 3]);
+   *     // BinaryTree doesn't guarantee BST order
+   *     console.log(typeof tree.isBST()); // 'boolean';
    */
   isBST(
     startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
@@ -1750,53 +1178,11 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param dist - The node to find the depth of.
    * @param [startNode=this._root] - The node to measure depth from (defaults to root).
    * @returns The depth (0 if `dist` is `startNode`).
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Get depth of a node
- *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
- *     const node = tree.getNode(4);
- *     console.log(tree.getDepth(node!)); // 2;
+   * @example
+   * // Get depth of a node
+   *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
+   *     const node = tree.getNode(4);
+   *     console.log(tree.getDepth(node!)); // 2;
    */
   getDepth(
     dist: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
@@ -1822,52 +1208,10 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param [startNode=this._root] - The node to start measuring from.
    * @param [iterationType=this.iterationType] - The traversal method.
    * @returns The height ( -1 for an empty tree, 0 for a single-node tree).
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Get tree height
- *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
- *     console.log(tree.getHeight()); // 2;
+   * @example
+   * // Get tree height
+   *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
+   *     console.log(tree.getHeight()); // 2;
    */
   getHeight(
     startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
@@ -2133,55 +1477,13 @@ export class BinaryTree<K = any, V = any, R = any>
     return y;
   }
 
-    /**
+  /**
    * Depth-first search traversal
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Depth-first search traversal
- *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
- *     const inOrder = tree.dfs(node => node.key, 'IN');
- *     console.log(inOrder); // [4, 2, 5, 1, 3];
+   * @example
+   * // Depth-first search traversal
+   *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
+   *     const inOrder = tree.dfs(node => node.key, 'IN');
+   *     console.log(inOrder); // [4, 2, 5, 1, 3];
    */
   dfs(): (K | undefined)[];
 
@@ -2228,77 +1530,35 @@ export class BinaryTree<K = any, V = any, R = any>
     return this._dfs(callback, pattern, onlyOne, startNode, iterationType, includeNull);
   }
 
-    /**
+  /**
    * BinaryTree level-order traversal
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // BinaryTree level-order traversal
- *  const tree = new BinaryTree([
- *       [1, 'one'],
- *       [2, 'two'],
- *       [3, 'three'],
- *       [4, 'four'],
- *       [5, 'five'],
- *       [6, 'six'],
- *       [7, 'seven']
- *     ]);
- *
- *     // Binary tree maintains level-order insertion
- *     // Complete binary tree structure
- *     console.log(tree.size); // 7;
- *
- *     // Verify all keys are present
- *     console.log(tree.has(1)); // true;
- *     console.log(tree.has(4)); // true;
- *     console.log(tree.has(7)); // true;
- *
- *     // Iterate through tree
- *     const keys: number[] = [];
- *     for (const [key] of tree) {
- *       keys.push(key);
- *     }
- *     console.log(keys.length); // 7;
+   * @example
+   * // BinaryTree level-order traversal
+   *  const tree = new BinaryTree([
+   *       [1, 'one'],
+   *       [2, 'two'],
+   *       [3, 'three'],
+   *       [4, 'four'],
+   *       [5, 'five'],
+   *       [6, 'six'],
+   *       [7, 'seven']
+   *     ]);
+   *
+   *     // Binary tree maintains level-order insertion
+   *     // Complete binary tree structure
+   *     console.log(tree.size); // 7;
+   *
+   *     // Verify all keys are present
+   *     console.log(tree.has(1)); // true;
+   *     console.log(tree.has(4)); // true;
+   *     console.log(tree.has(7)); // true;
+   *
+   *     // Iterate through tree
+   *     const keys: number[] = [];
+   *     for (const [key] of tree) {
+   *       keys.push(key);
+   *     }
+   *     console.log(keys.length); // 7;
    */
   bfs(): (K | undefined)[];
 
@@ -2384,53 +1644,13 @@ export class BinaryTree<K = any, V = any, R = any>
     return ans;
   }
 
-    /**
+  /**
    * Get leaf nodes
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Get leaf nodes
- *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
- *     const leafKeys = tree.leaves(node => node.key);
- *     console.log(leafKeys.length); // > 0;
+   * @example
+   * // Get leaf nodes
+   *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
+   *     const leafKeys = tree.leaves(node => node.key);
+   *     console.log(leafKeys.length); // > 0;
    */
   leaves(): (K | undefined)[];
 
@@ -2492,53 +1712,14 @@ export class BinaryTree<K = any, V = any, R = any>
     return leaves;
   }
 
-    /**
+  /**
    * Level-order grouping
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Level-order grouping
- *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
- *     const levels = tree.listLevels(node => node.key);
- *     console.log(levels[0]); // [1];
- *     console.log(levels[1].sort()); // [2, 3];
+   * @example
+   * // Level-order grouping
+   *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
+   *     const levels = tree.listLevels(node => node.key);
+   *     console.log(levels[0]); // [1];
+   *     console.log(levels[1].sort()); // [2, 3];
    */
   listLevels(): (K | undefined)[][];
 
@@ -2617,52 +1798,13 @@ export class BinaryTree<K = any, V = any, R = any>
     return levelsNodes;
   }
 
-    /**
+  /**
    * Morris traversal (O(1) space)
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Morris traversal (O(1) space)
- *  const tree = new BinaryTree<number>([1, 2, 3]);
- *     const result = tree.morris(node => node.key, 'IN');
- *     console.log(result.length); // 3;
+   * @example
+   * // Morris traversal (O(1) space)
+   *  const tree = new BinaryTree<number>([1, 2, 3]);
+   *     const result = tree.morris(node => node.key, 'IN');
+   *     console.log(result.length); // 3;
    */
   morris(): (K | undefined)[];
 
@@ -2787,52 +1929,12 @@ export class BinaryTree<K = any, V = any, R = any>
    * @remarks Time O(N * M), where N is the number of nodes and M is the tree size during insertion (due to `bfs` + `set`, and `set` is O(M)). Space O(N) for the new tree and the BFS queue.
    *
    * @returns A new, cloned instance of the tree.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Deep copy
- *  const tree = new BinaryTree<number>([1, 2, 3]);
- *     const copy = tree.clone();
- *     copy.delete(1);
- *     console.log(tree.has(1)); // true;
+   * @example
+   * // Deep copy
+   *  const tree = new BinaryTree<number>([1, 2, 3]);
+   *     const copy = tree.clone();
+   *     copy.delete(1);
+   *     console.log(tree.has(1)); // true;
    */
   clone(): this {
     const out = this._createInstance<K, V, R>();
@@ -2847,51 +1949,11 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param predicate - A function to test each [key, value] pair.
    * @param [thisArg] - `this` context for the predicate.
    * @returns A new, filtered tree.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Filter nodes by condition
- *  const tree = new BinaryTree<number>([1, 2, 3, 4]);
- *     const result = tree.filter((_, key) => key > 2);
- *     console.log(result.size); // 2;
+   * @example
+   * // Filter nodes by condition
+   *  const tree = new BinaryTree<number>([1, 2, 3, 4]);
+   *     const result = tree.filter((_, key) => key > 2);
+   *     console.log(result.size); // 2;
    */
   filter(predicate: EntryCallback<K, V | undefined, boolean>, thisArg?: unknown): this {
     const out = this._createInstance<K, V, R>();
@@ -2911,51 +1973,14 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param [options] - Options for the new tree.
    * @param [thisArg] - `this` context for the callback.
    * @returns A new, mapped tree.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Transform to new tree
- *  const tree = new BinaryTree<number, number>([[1, 10], [2, 20]]);
- *     const mapped = tree.map((v, key) => [key, (v ?? 0) + 1] as [number, number]);
- *     console.log([...mapped.values()]); // contains 11;
+   * @example
+   * // Transform to new tree
+   *  const tree = new BinaryTree<number, number>([
+   *       [1, 10],
+   *       [2, 20]
+   *     ]);
+   *     const mapped = tree.map((v, key) => [key, (v ?? 0) + 1] as [number, number]);
+   *     console.log([...mapped.values()]); // contains 11;
    */
   map<MK = K, MV = V, MR = any>(
     cb: EntryCallback<K, V | undefined, [MK, MV]>,
@@ -3008,50 +2033,10 @@ export class BinaryTree<K = any, V = any, R = any>
    *
    * @param [options] - Options to control the output.
    * @param [startNode=this._root] - The node to start printing from.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Display tree
- *  const tree = new BinaryTree<number>([1, 2, 3]);
- *     expect(() => tree.print()).not.toThrow();
+   * @example
+   * // Display tree
+   *  const tree = new BinaryTree<number>([1, 2, 3]);
+   *     expect(() => tree.print()).not.toThrow();
    */
   override print(
     options?: BinaryTreePrintOptions,
@@ -3060,6 +2045,67 @@ export class BinaryTree<K = any, V = any, R = any>
     console.log(this.toVisual(startNode, options));
   }
 
+  /**
+   * Deletes a node from the tree (internal, returns balancing metadata).
+   * @remarks Time O(N) — O(N) to find the node + O(H) for predecessor swap. Space O(1). BST/Red-Black Tree/AVL Tree subclasses override to O(log N).
+   * @internal Used by AVL/BST subclasses that need balancing metadata after deletion.
+   *
+   * @param keyNodeEntryRawOrPredicate - The node to delete.
+   * @returns An array containing deletion results with balancing metadata.
+   */
+  protected _deleteInternal(
+    keyNodeEntryRawOrPredicate: BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V> | null>
+  ): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[] {
+    const deletedResult: BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[] = [];
+    if (!this._root) return deletedResult;
+
+    const curr = this.getNode(keyNodeEntryRawOrPredicate);
+    if (!curr) return deletedResult;
+
+    const parent: BinaryTreeNode<K, V> | undefined = curr?.parent;
+    let needBalanced: BinaryTreeNode<K, V> | undefined;
+    let orgCurrent: BinaryTreeNode<K, V> | undefined = curr;
+
+    if (!curr.left && !curr.right && !parent) {
+      this._setRoot(undefined);
+    } else if (curr.left) {
+      const leftSubTreeRightMost = this.getRightMost(node => node, curr.left);
+      if (leftSubTreeRightMost) {
+        const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
+        orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
+
+        if (this._isMapMode) {
+          this._store.set(curr.key, curr);
+          this._store.set(leftSubTreeRightMost.key, leftSubTreeRightMost);
+        }
+
+        if (parentOfLeftSubTreeMax) {
+          if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
+            parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
+          else parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
+          needBalanced = parentOfLeftSubTreeMax;
+        }
+      }
+    } else if (parent) {
+      const { familyPosition: fp } = curr;
+      if (fp === 'LEFT' || fp === 'ROOT_LEFT') {
+        parent.left = curr.right;
+      } else if (fp === 'RIGHT' || fp === 'ROOT_RIGHT') {
+        parent.right = curr.right;
+      }
+      needBalanced = parent;
+    } else {
+      this._setRoot(curr.right);
+      curr.right = undefined;
+    }
+
+    this._size = this._size - 1;
+
+    deletedResult.push({ deleted: orgCurrent, needBalanced });
+    if (this._isMapMode && orgCurrent) this._store.delete(orgCurrent.key);
+    return deletedResult;
+  }
+
   protected _dfs<C extends NodeCallback<BinaryTreeNode<K, V>>>(
     callback: C,
     pattern?: DFSOrderPattern,
@@ -3249,8 +2295,9 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param node - The node.
    * @returns The node's key or undefined.
    */
-  protected readonly _DEFAULT_NODE_CALLBACK: NodeCallback<BinaryTreeNode<K, V> | null | undefined, K | undefined> =
-    (node): K | undefined => node?.key;
+  protected readonly _DEFAULT_NODE_CALLBACK: NodeCallback<BinaryTreeNode<K, V> | null | undefined, K | undefined> = (
+    node
+  ): K | undefined => node?.key;
 
   /**
    * (Protected) Snapshots the current tree's configuration options.
@@ -3382,14 +2429,20 @@ export class BinaryTree<K = any, V = any, R = any>
     };
 
     const newFrame = (n: BinaryTreeNode<K, V> | null | undefined): Frame => ({
-      node: n, stage: 0, leftLayout: emptyDisplayLayout, rightLayout: emptyDisplayLayout
+      node: n,
+      stage: 0,
+      leftLayout: emptyDisplayLayout,
+      rightLayout: emptyDisplayLayout
     });
 
     const stack: Frame[] = [newFrame(node)];
     let result: NodeDisplayLayout = emptyDisplayLayout;
 
     const setChildResult = (layout: NodeDisplayLayout) => {
-      if (stack.length === 0) { result = layout; return; }
+      if (stack.length === 0) {
+        result = layout;
+        return;
+      }
       const parent = stack[stack.length - 1];
       if (parent.stage === 1) parent.leftLayout = layout;
       else parent.rightLayout = layout;
@@ -3423,48 +2476,10 @@ export class BinaryTree<K = any, V = any, R = any>
     return result;
   }
 
-  protected static _buildNodeDisplay(line: string, width: number, left: NodeDisplayLayout, right: NodeDisplayLayout) {
-      const [leftLines, leftWidth, leftHeight, leftMiddle] = left;
-      const [rightLines, rightWidth, rightHeight, rightMiddle] = right;
-      const firstLine =
-        ' '.repeat(Math.max(0, leftMiddle + 1)) +
-        '_'.repeat(Math.max(0, leftWidth - leftMiddle - 1)) +
-        line +
-        '_'.repeat(Math.max(0, rightMiddle)) +
-        ' '.repeat(Math.max(0, rightWidth - rightMiddle));
-
-      const secondLine =
-        (leftHeight > 0
-          ? ' '.repeat(leftMiddle) + '/' + ' '.repeat(leftWidth - leftMiddle - 1)
-          : ' '.repeat(leftWidth)) +
-        ' '.repeat(width) +
-        (rightHeight > 0
-          ? ' '.repeat(rightMiddle) + '\\' + ' '.repeat(rightWidth - rightMiddle - 1)
-          : ' '.repeat(rightWidth));
-
-      const mergedLines = [firstLine, secondLine];
-
-      for (let i = 0; i < Math.max(leftHeight, rightHeight); i++) {
-        const leftLine = i < leftHeight ? leftLines[i] : ' '.repeat(leftWidth);
-        const rightLine = i < rightHeight ? rightLines[i] : ' '.repeat(rightWidth);
-        mergedLines.push(leftLine + ' '.repeat(width) + rightLine);
-      }
-
-      return <NodeDisplayLayout>[
-        mergedLines,
-        leftWidth + width + rightWidth,
-        Math.max(leftHeight, rightHeight) + 2,
-        leftWidth + Math.floor(width / 2)
-      ];
-  }
-
   /**
    * Check if a node is a display leaf (empty, null, undefined, NIL, or real leaf).
    */
-  protected _isDisplayLeaf(
-    node: BinaryTreeNode<K, V> | null | undefined,
-    options: BinaryTreePrintOptions
-  ): boolean {
+  protected _isDisplayLeaf(node: BinaryTreeNode<K, V> | null | undefined, options: BinaryTreePrintOptions): boolean {
     const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
     // Empty/hidden nodes are always leaves
     if (node === null && !isShowNull) return true;