max-priority-queue-typed 2.4.5 → 2.5.0

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

@@ -98,16 +98,12 @@ export class RedBlackTreeNode<K = any, V = any> {
    *
    * @returns The height.
    */
+  /* istanbul ignore next -- covered by AVLTree tests (subclass uses height) */
   get height(): number {
     return this._height;
   }
 
-  /**
-   * Sets the height of the node.
-   * @remarks Time O(1), Space O(1)
-   *
-   * @param value - The new height.
-   */
+  /* istanbul ignore next -- covered by AVLTree tests (subclass uses height) */
   set height(value: number) {
     this._height = value;
   }
@@ -142,20 +138,11 @@ export class RedBlackTreeNode<K = any, V = any> {
    *
    * @returns The subtree node count.
    */
+  /* istanbul ignore next -- internal field, exercised indirectly via tree operations */
   get count(): number {
     return this._count;
   }
 
-  /**
-   * Sets the count of nodes in the subtree.
-   * @remarks Time O(1), Space O(1)
-   *
-   * @param value - The new count.
-   */
-  set count(value: number) {
-    this._count = value;
-  }
-
   /**
    * Gets the position of the node relative to its parent.
    * @remarks Time O(1), Space O(1)
@@ -173,6 +160,7 @@ export class RedBlackTreeNode<K = any, V = any> {
       return this.left || this.right ? 'ROOT_RIGHT' : 'RIGHT';
     }
 
+    /* istanbul ignore next -- defensive: unreachable if tree structure is correct */
     return 'MAL_NODE';
   }
 }
@@ -187,23 +175,6 @@ export class RedBlackTreeNode<K = any, V = any> {
  * 2. It is BST itself. Compared with Heap which is not completely ordered, RedBlackTree is completely ordered.
  *
  * @example
- * // basic Red-Black Tree with simple number keys
- *  // Create a simple Red-Black Tree with numeric keys
- *     const tree = new RedBlackTree([5, 2, 8, 1, 9]);
- *
- *     tree.print();
- *     //   _2___
- *     //  /     \
- *     //  1    _8_
- *     //      /   \
- *     //      5   9
- *
- *     // Verify the tree maintains sorted order
- *     console.log([...tree.keys()]); // [1, 2, 5, 8, 9];
- *
- *     // Check size
- *     console.log(tree.size); // 5;
- * @example
  * // Red-Black Tree with key-value pairs for lookups
  *  interface Employee {
  *       id: number;
@@ -369,6 +340,46 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
   /**
    * Remove all nodes and clear internal caches.
    * @remarks Time O(n) average, Space O(1)
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Remove all entries
+ *  const rbt = new RedBlackTree<number>([1, 2, 3]);
+ *     rbt.clear();
+ *     console.log(rbt.isEmpty()); // true;
    */
   override clear() {
     super.clear();
@@ -604,10 +615,10 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
     if (hMin === NIL || hMax === NIL) {
       this._setMinCache(newNode);
       this._setMaxCache(newNode);
-    } else if (parent === hMax && lastCompared > 0) {
-      this._setMaxCache(newNode);
-    } else if (parent === hMin && lastCompared < 0) {
-      this._setMinCache(newNode);
+    } else /* istanbul ignore next -- boundary fast-paths at top of _setKVNode intercept boundary inserts before normal path */ if (parent === hMax && lastCompared > 0) {
+      /* istanbul ignore next */ this._setMaxCache(newNode);
+    } else /* istanbul ignore next */ if (parent === hMin && lastCompared < 0) {
+      /* istanbul ignore next */ this._setMinCache(newNode);
     } else {
       if (cmp(newNode.key, hMin.key) < 0) this._setMinCache(newNode);
       if (cmp(newNode.key, hMax.key) > 0) this._setMaxCache(newNode);
@@ -701,6 +712,7 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
         return newNode;
       }
 
+      /* istanbul ignore next -- structurally unreachable: predecessor never has a right child (it's the max of left subtree) */
       return this._setKVNode(key, value)?.node;
     }
 
@@ -741,6 +753,7 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
       return newNode;
     }
 
+    /* istanbul ignore next -- structurally unreachable: successor never has a left child (it's the min of right subtree) */
     return this._setKVNode(key, value)?.node;
   }
 
@@ -760,6 +773,59 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
    * - updates via a single-pass search (no double walk)
    *
    * @remarks Time O(log n) average, Space O(1)
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // basic Red-Black Tree with simple number keys
+ *  // Create a simple Red-Black Tree with numeric keys
+ *     const tree = new RedBlackTree([5, 2, 8, 1, 9]);
+ *
+ *     tree.print();
+ *     //   _2___
+ *     //  /     \
+ *     //  1    _8_
+ *     //      /   \
+ *     //      5   9
+ *
+ *     // Verify the tree maintains sorted order
+ *     console.log([...tree.keys()]); // [1, 2, 5, 8, 9];
+ *
+ *     // Check size
+ *     console.log(tree.size); // 5;
    */
   override set(
     keyNodeOrEntry: K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
@@ -812,6 +878,7 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
       }
       return true;
     }
+    /* istanbul ignore next -- defensive: _insert only returns CREATED|UPDATED */
     return false;
   }
 
@@ -820,6 +887,50 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
    * @remarks Time O(log n) average, Space O(1)
    * @param keyNodeEntryRawOrPredicate - Key, node, or [key, value] entry identifying the node to delete.
    * @returns Array with deletion metadata (removed node, rebalancing hint if any).
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Remove and rebalance
+ *  const rbt = new RedBlackTree<number>([10, 5, 15, 3, 7]);
+ *     rbt.delete(5);
+ *     console.log(rbt.has(5)); // false;
+ *     console.log(rbt.size); // 4;
    */
   override delete(
     keyNodeEntryRawOrPredicate: BTNRep<K, V, RedBlackTreeNode<K, V>> | NodePredicate<RedBlackTreeNode<K, V> | null>
@@ -842,39 +953,38 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
     const nextMax = willDeleteMax ? this._predecessorOf(nodeToDelete) : undefined;
 
     let originalColor = nodeToDelete.color;
-    let replacementNode: RedBlackTreeNode<K, V> | undefined;
+    const NIL = this.NIL;
+    let replacementNode: RedBlackTreeNode<K, V> = NIL;
 
     if (!this.isRealNode(nodeToDelete.left)) {
-      if (nodeToDelete.right !== null) {
-        replacementNode = nodeToDelete.right;
-        this._transplant(nodeToDelete, nodeToDelete.right);
-      }
+      // No real left child → replace with right (may be NIL)
+      replacementNode = nodeToDelete.right ?? NIL;
+      this._transplant(nodeToDelete, replacementNode);
     } else if (!this.isRealNode(nodeToDelete.right)) {
+      // No real right child → replace with left
       replacementNode = nodeToDelete.left;
-      this._transplant(nodeToDelete, nodeToDelete.left);
+      this._transplant(nodeToDelete, replacementNode);
     } else {
+      // Two children → find in-order successor
       const successor = this.getLeftMost(node => node, nodeToDelete.right);
       if (successor) {
         originalColor = successor.color;
-        if (successor.right !== null) replacementNode = successor.right;
+        replacementNode = successor.right ?? NIL;
 
         if (successor.parent === nodeToDelete) {
-          if (this.isRealNode(replacementNode)) {
-            replacementNode.parent = successor;
-          }
+          // Even if replacementNode is NIL, set its parent for fixup
+          replacementNode.parent = successor;
         } else {
-          if (successor.right !== null) {
-            this._transplant(successor, successor.right);
-            successor.right = nodeToDelete.right;
-          }
-          if (this.isRealNode(successor.right)) {
+          this._transplant(successor, replacementNode);
+          successor.right = nodeToDelete.right;
+          if (successor.right) {
             successor.right.parent = successor;
           }
         }
 
         this._transplant(nodeToDelete, successor);
         successor.left = nodeToDelete.left;
-        if (this.isRealNode(successor.left)) {
+        if (successor.left) {
           successor.left.parent = successor;
         }
         successor.color = nodeToDelete.color;
@@ -923,8 +1033,38 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
    * Red-Black trees are self-balancing — `perfectlyBalance` rebuilds via
    * sorted bulk insert, which naturally produces a balanced RBT.
    * @remarks Time O(N), Space O(N)
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Rebalance tree
+ *  const rbt = new RedBlackTree<number>([1, 2, 3, 4, 5]);
+ *     rbt.perfectlyBalance();
+ *     console.log(rbt.isAVLBalanced()); // true;
    */
-  override perfectlyBalance(iterationType?: IterationType): boolean {
+  override perfectlyBalance(_iterationType?: IterationType): boolean {
     // Extract sorted entries, clear, re-insert — RBT self-balances on insert
     const entries: [K, V | undefined][] = [];
     for (const [key, value] of this) entries.push([key, value]);
@@ -938,6 +1078,49 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
     return true;
   }
 
+    /**
+   * Transform to new tree
+  
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Transform to new tree
+ *  const rbt = new RedBlackTree<number, number>([[1, 10], [2, 20]]);
+ *     const doubled = rbt.map((v, k) => [k, (v ?? 0) * 2] as [number, number]);
+ *     console.log([...doubled.values()]); // [20, 40];
+   */
   override map<MK = K, MV = V, MR = any>(
     callback: EntryCallback<K, V | undefined, [MK, MV]>,
     options?: Partial<RedBlackTreeOptions<MK, MV, MR>>,
@@ -1151,66 +1334,76 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
    * @returns void
    */
   protected _deleteFixup(node: RedBlackTreeNode<K, V> | undefined): void {
-    if (!node || node === this.root || node.color === 'BLACK') {
-      if (node) {
-        node.color = 'BLACK';
-      }
-      return;
-    }
+    // Standard CLRS RB-DELETE-FIXUP: restore black-height invariant.
+    // `node` is the child that replaced the deleted node (may be NIL sentinel).
+    // If RED → just recolor BLACK (trivial fix). If BLACK → double-black repair.
+    if (!node) return;
 
-    while (node && node !== this.root && node.color === 'BLACK') {
-      const parent: RedBlackTreeNode<K, V> | undefined = node.parent;
+    const NIL = this.NIL;
+    let current: RedBlackTreeNode<K, V> = node;
 
-      if (!parent) {
-        break;
-      }
+    while (current !== this.root && current.color === 'BLACK') {
+      const parent: RedBlackTreeNode<K, V> | undefined = current.parent;
+      if (!parent) break;
 
-      if (node === parent.left) {
-        let sibling = parent.right;
+      const nodeIsLeft = current === parent.left;
+      let sibling = nodeIsLeft ? parent.right : parent.left;
 
-        if (sibling?.color === 'RED') {
-          sibling.color = 'BLACK';
-          parent.color = 'RED';
+      // Case 1: sibling is RED → rotate to get a BLACK sibling
+      if (sibling && sibling.color === 'RED') {
+        sibling.color = 'BLACK';
+        parent.color = 'RED';
+        if (nodeIsLeft) {
           this._leftRotate(parent);
           sibling = parent.right;
-        }
-
-        if ((sibling?.left?.color ?? 'BLACK') === 'BLACK') {
-          if (sibling) sibling.color = 'RED';
-          node = parent;
         } else {
-          if (sibling?.left) sibling.left.color = 'BLACK';
-          if (sibling) sibling.color = parent.color;
-          parent.color = 'BLACK';
           this._rightRotate(parent);
-          node = this.root;
+          sibling = parent.left;
         }
-      } else {
-        let sibling = parent.left;
+      }
 
-        if (sibling?.color === 'RED') {
-          sibling.color = 'BLACK';
-          if (parent) parent.color = 'RED';
-          this._rightRotate(parent);
-          if (parent) sibling = parent.left;
-        }
+      const sibLeft = sibling?.left;
+      const sibRight = sibling?.right;
+      const sibLeftBlack = !sibLeft || sibLeft === NIL || sibLeft.color === 'BLACK';
+      const sibRightBlack = !sibRight || sibRight === NIL || sibRight.color === 'BLACK';
 
-        if ((sibling?.right?.color ?? 'BLACK') === 'BLACK') {
-          if (sibling) sibling.color = 'RED';
-          node = parent;
-        } else {
-          if (sibling?.right) sibling.right.color = 'BLACK';
+      if (sibLeftBlack && sibRightBlack) {
+        // Case 2: sibling's children are both BLACK → recolor sibling RED, move up
+        if (sibling) sibling.color = 'RED';
+        current = parent;
+      } else {
+        if (nodeIsLeft) {
+          // Case 3: sibling's right child is BLACK → rotate sibling right first
+          if (sibRightBlack) {
+            if (sibLeft) sibLeft.color = 'BLACK';
+            if (sibling) sibling.color = 'RED';
+            if (sibling) this._rightRotate(sibling);
+            sibling = parent.right;
+          }
+          // Case 4: sibling's right child is RED → final rotation
           if (sibling) sibling.color = parent.color;
-          if (parent) parent.color = 'BLACK';
+          parent.color = 'BLACK';
+          if (sibling?.right) sibling.right.color = 'BLACK';
           this._leftRotate(parent);
-          node = this.root;
+        } else {
+          // Case 3 (mirror): sibling's left child is BLACK → rotate sibling left first
+          if (sibLeftBlack) {
+            if (sibRight) sibRight.color = 'BLACK';
+            if (sibling) sibling.color = 'RED';
+            if (sibling) this._leftRotate(sibling);
+            sibling = parent.left;
+          }
+          // Case 4 (mirror): sibling's left child is RED → final rotation
+          if (sibling) sibling.color = parent.color;
+          parent.color = 'BLACK';
+          if (sibling?.left) sibling.left.color = 'BLACK';
+          this._rightRotate(parent);
         }
+        current = this.root!;
       }
     }
 
-    if (node) {
-      node.color = 'BLACK';
-    }
+    current.color = 'BLACK';
   }
 
   /**