binary-tree-typed 2.4.5 → 2.5.1

package/dist/types/data-structures/binary-tree/red-black-tree.d.ts

@@ -56,12 +56,6 @@ export declare class RedBlackTreeNode<K = any, V = any> {
      * @returns The height.
      */
     get height(): number;
-    /**
-     * Sets the height of the node.
-     * @remarks Time O(1), Space O(1)
-     *
-     * @param value - The new height.
-     */
     set height(value: number);
     _color: RBTNColor;
     /**
@@ -86,13 +80,6 @@ export declare class RedBlackTreeNode<K = any, V = any> {
      * @returns The subtree node count.
      */
     get count(): number;
-    /**
-     * Sets the count of nodes in the subtree.
-     * @remarks Time O(1), Space O(1)
-     *
-     * @param value - The new count.
-     */
-    set count(value: number);
     /**
      * Gets the position of the node relative to its parent.
      * @remarks Time O(1), Space O(1)
@@ -111,23 +98,6 @@ export declare 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;
@@ -254,6 +224,130 @@ export declare class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R
     /**
      * 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;
      */
     clear(): void;
     /**
@@ -355,6 +449,143 @@ export declare class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R
      * - 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;
      */
     set(keyNodeOrEntry: K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V): boolean;
     /**
@@ -362,6 +593,134 @@ export declare class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R
      * @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;
      */
     delete(keyNodeEntryRawOrPredicate: BTNRep<K, V, RedBlackTreeNode<K, V>> | NodePredicate<RedBlackTreeNode<K, V> | null>): BinaryTreeDeleteResult<RedBlackTreeNode<K, V>>[];
     /**
@@ -379,8 +738,228 @@ export declare class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R
      * 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;
      */
-    perfectlyBalance(iterationType?: IterationType): boolean;
+    perfectlyBalance(_iterationType?: IterationType): boolean;
+    /**
+   * 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];
+   */
     map<MK = K, MV = V, MR = any>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<RedBlackTreeOptions<MK, MV, MR>>, thisArg?: unknown): RedBlackTree<MK, MV, MR>;
     /**
      * (Internal) Create an empty instance of the same concrete tree type.