max-priority-queue-typed 2.4.5 → 2.5.1

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

@@ -80,12 +80,6 @@ export declare class AVLTreeNode<K = any, V = any> {
      * @returns The node's color.
      */
     get color(): RBTNColor;
-    /**
-     * Sets the color of the node.
-     * @remarks Time O(1), Space O(1)
-     *
-     * @param value - The new color.
-     */
     set color(value: RBTNColor);
     _count: number;
     /**
@@ -95,12 +89,6 @@ export declare class AVLTreeNode<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.
@@ -127,28 +115,6 @@ export declare class AVLTreeNode<K = any, V = any> {
  * 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.
  *
  * @example
- * // basic AVLTree creation and add operation
- *  // Create a simple AVLTree with initial values
- *     const tree = new AVLTree([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;
- *
- *     // Add a new element
- *     tree.set(3);
- *     console.log(tree.size); // 6;
- *     console.log([...tree.keys()]); // [1, 2, 3, 5, 8, 9];
- * @example
  * // AVLTree has and get operations
  *  const tree = new AVLTree<number>([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
  *
@@ -163,23 +129,6 @@ export declare class AVLTreeNode<K = any, V = any> {
  *     // Verify tree is balanced
  *     console.log(tree.isAVLBalanced()); // true;
  * @example
- * // AVLTree delete and balance verification
- *  const tree = new AVLTree([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
- *
- *     // Delete an element
- *     tree.delete(10);
- *     console.log(tree.has(10)); // false;
- *
- *     // Tree should remain balanced after deletion
- *     console.log(tree.isAVLBalanced()); // true;
- *
- *     // Size decreased
- *     console.log(tree.size); // 15;
- *
- *     // Remaining elements are still sorted
- *     const keys = [...tree.keys()];
- *     console.log(keys); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16];
- * @example
  * // AVLTree for university ranking system with strict balance
  *  interface University {
  *       name: string;
@@ -318,6 +267,132 @@ export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> imp
      * @param keyNodeOrEntry - The key, node, or entry to set.
      * @param [value] - The value, if providing just a key.
      * @returns True if the addition was successful, false otherwise.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Set a key-value pair
+   *  const avl = new AVLTree<number, string>();
+   *     avl.set(1, 'one');
+   *     avl.set(2, 'two');
+   *     console.log(avl.get(1)); // 'one';
      */
     set(keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V): boolean;
     /**
@@ -326,6 +401,108 @@ export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> imp
      *
      * @param keyNodeOrEntry - The node to delete.
      * @returns An array containing deletion results.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Remove nodes and verify structure
+   *  const avl = new AVLTree<number>([5, 3, 7, 1, 4, 6, 8]);
+   *     avl.delete(3);
+   *     console.log(avl.has(3)); // false;
+   *     console.log(avl.size); // 6;
      */
     delete(keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): BinaryTreeDeleteResult<AVLTreeNode<K, V>>[];
     /**
@@ -335,6 +512,68 @@ export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> imp
      *
      * @param [iterationType=this.iterationType] - The traversal method for the initial node export.
      * @returns True if successful, false if the tree was empty.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Rebalance the tree
+   *  const avl = new AVLTree<number>();
+   *     // Insert in sorted order (worst case for BST)
+   *     for (let i = 1; i <= 7; i++) avl.add(i);
+   *     console.log(avl.isAVLBalanced()); // false;
+   *     avl.perfectlyBalance();
+   *     console.log(avl.isAVLBalanced()); // true;
      */
     perfectlyBalance(iterationType?: IterationType): boolean;
     /**
@@ -348,6 +587,96 @@ export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> imp
      * @param [options] - Options for the new AVLTree.
      * @param [thisArg] - `this` context for the callback.
      * @returns A new, mapped AVLTree.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Transform to new tree
+   *  const avl = new AVLTree<number, number>([[1, 10], [2, 20], [3, 30]]);
+   *     const doubled = avl.map((value, key) => [key, (value ?? 0) * 2] as [number, number]);
+   *     console.log([...doubled.values()]); // [20, 40, 60];
      */
     map<MK = K, MV = V, MR = any>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<BinaryTreeOptions<MK, MV, MR>>, thisArg?: unknown): AVLTree<MK, MV, MR>;
     /**