priority-queue-typed 1.47.5 → 1.47.7

package/dist/data-structures/binary-tree/bst.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNested, BSTNodeNested, BSTOptions, BTNCallback, BTNKey } from '../../types';
+import type { BSTNested, BSTNodeKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, BTNKey, BTNodeExemplar, Comparator } from '../../types';
 import { CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
@@ -33,19 +33,28 @@ export declare class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>
      */
     set right(v: N | undefined);
 }
+/**
+ * 1. Node Order: Each node's left child has a lesser value, and the right child has a greater value.
+ * 2. Unique Keys: No duplicate keys in a standard BST.
+ * 3. Efficient Search: Enables quick search, minimum, and maximum operations.
+ * 4. Inorder Traversal: Yields nodes in ascending order.
+ * 5. Logarithmic Operations: Ideal operations like insertion, deletion, and searching are O(log n) time-efficient.
+ * 6. Balance Variability: Can become unbalanced; special types maintain balance.
+ * 7. No Auto-Balancing: Standard BSTs don't automatically balance themselves.
+ */
 export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>, TREE extends BST<V, N, TREE> = BST<V, N, BSTNested<V, N>>> extends BinaryTree<V, N, TREE> implements IBinaryTree<V, N, TREE> {
-    options: BSTOptions;
     /**
-     * The constructor function initializes a binary search tree with an optional comparator function.
-     * @param {BSTOptions} [options] - An optional object that contains additional configuration options
-     * for the binary search tree.
+     * This is the constructor function for a binary search tree class in TypeScript, which initializes
+     * the tree with optional elements and options.
+     * @param [elements] - An optional iterable of BTNodeExemplar objects that will be added to the
+     * binary search tree.
+     * @param [options] - The `options` parameter is an optional object that can contain additional
+     * configuration options for the binary search tree. It can have the following properties:
      */
-    constructor(options?: BSTOptions);
+    constructor(elements?: Iterable<BTNodeExemplar<V, N>>, options?: Partial<BSTOptions>);
     protected _root?: N;
-    /**
-     * Get the root node of the binary tree.
-     */
     get root(): N | undefined;
+    comparator: Comparator<BTNKey>;
     /**
      * The function creates a new binary search tree node with the given key and value.
      * @param {BTNKey} key - The key parameter is the key value that will be associated with
@@ -55,7 +64,14 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @returns a new instance of the BSTNode class with the specified key and value.
      */
     createNode(key: BTNKey, value?: V): N;
-    createTree(options?: BSTOptions): TREE;
+    /**
+     * The function creates a new binary search tree with the specified options.
+     * @param [options] - The `options` parameter is an optional object that allows you to customize the
+     * behavior of the `createTree` method. It accepts a partial `BSTOptions` object, which is a type
+     * that defines various options for creating a binary search tree.
+     * @returns a new instance of the BST class with the specified options.
+     */
+    createTree(options?: Partial<BSTOptions>): TREE;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      * Space Complexity: O(1) - Constant space is used.
@@ -64,43 +80,37 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      * Space Complexity: O(1) - Constant space is used.
      *
-     * The `add` function adds a new node to a binary search tree based on the provided key and value.
-     * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
-     * following types:
-     * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
-     * key or node being added to the binary search tree.
-     * @returns The method `add` returns a node (`N`) that was inserted into the binary search tree. If
-     * no node was inserted, it returns `undefined`.
+     * The `add` function adds a new node to a binary search tree, either by key or by providing a node
+     * object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
+     * @returns The method returns either the newly added node (`newNode`) or `undefined` if the input
+     * (`keyOrNodeOrEntry`) is null, undefined, or does not match any of the expected types.
      */
-    add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | undefined;
+    add(keyOrNodeOrEntry: BTNodeExemplar<V, N>): N | undefined;
     /**
-     * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
-     * Space Complexity: O(n) - Additional space is required for the sorted array.
+     * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
+     * Space Complexity: O(k) - Additional space is required for the sorted array.
      */
     /**
-     * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
-     * Space Complexity: O(n) - Additional space is required for the sorted array.
+     * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
+     * Space Complexity: O(k) - Additional space is required for the sorted array.
      *
-     * The `addMany` function is used to efficiently add multiple keys or nodes with corresponding data
-     * to a binary search tree.
-     * @param {(BTNKey | N | undefined)[]} keysOrNodes - An array of keys or nodes to be added to the
-     * binary search tree. Each element can be of type `BTNKey` (binary tree node key), `N` (binary tree
-     * node), or `undefined`.
-     * @param {(V | undefined)[]} [data] - An optional array of values to associate with the keys or
-     * nodes being added. If provided, the length of the `data` array must be the same as the length of
-     * the `keysOrNodes` array.
+     * The `addMany` function in TypeScript adds multiple nodes to a binary tree, either in a balanced or
+     * unbalanced manner, and returns an array of the inserted nodes.
+     * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries to be added to the
+     * binary tree.
      * @param [isBalanceAdd=true] - A boolean flag indicating whether the tree should be balanced after
-     * adding the nodes. The default value is `true`.
+     * adding the nodes. The default value is true.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when adding multiple keys or nodes to the binary search tree. It has a
-     * default value of `this.iterationType`, which means it will use the iteration type specified in the
-     * current instance of the binary search tree
-     * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
+     * type of iteration to use when adding multiple keys or nodes to the binary tree. It has a default
+     * value of `this.iterationType`, which means it will use the iteration type specified by the binary
+     * tree instance.
+     * @returns The `addMany` function returns an array of `N` or `undefined` values.
      */
-    addMany(keysOrNodes: (BTNKey | N | undefined)[], data?: (V | undefined)[], isBalanceAdd?: boolean, iterationType?: IterationType | undefined): (N | undefined)[];
+    addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<V, N>>, isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(1) - Constant space is used.
+     * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
+     * Space Complexity: O(n) - Additional space is required for the sorted array.
      */
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
@@ -117,10 +127,10 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * the key of the leftmost node if the comparison result is greater than, and the key of the
      * rightmost node otherwise. If no node is found, it returns 0.
      */
-    lastKey(beginRoot?: BTNKey | N | undefined, iterationType?: IterationType | undefined): BTNKey;
+    lastKey(beginRoot?: BSTNodeKeyOrNode<N>, iterationType?: IterationType): BTNKey;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Space Complexity: O(1) - Constant space is used.
      */
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
@@ -138,7 +148,11 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      */
     getNodeByKey(key: BTNKey, iterationType?: IterationType): N | undefined;
     /**
-     * The function `ensureNotKey` returns the node corresponding to the given key if it is a node key,
+     * Time Complexity: O(log n) - Average case for a balanced tree.
+     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     */
+    /**
+     * The function `ensureNode` returns the node corresponding to the given key if it is a node key,
      * otherwise it returns the key itself.
      * @param {BTNKey | N | undefined} key - The `key` parameter can be of type `BTNKey`, `N`, or
      * `undefined`.
@@ -146,11 +160,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
      * @returns either a node object (N) or undefined.
      */
-    ensureNotKey(key: BTNKey | N | undefined, iterationType?: IterationType): N | undefined;
-    /**
-     * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
-     */
+    ensureNode(key: BSTNodeKeyOrNode<N>, iterationType?: IterationType): N | undefined;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -174,7 +184,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * performed on the binary tree. It can have two possible values:
      * @returns The method returns an array of nodes (`N[]`).
      */
-    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BTNKey | N | undefined, iterationType?: IterationType | undefined): N[];
+    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BSTNodeKeyOrNode<N>, iterationType?: IterationType): N[];
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -200,19 +210,10 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BTNKey | N | undefined, iterationType?: IterationType | undefined): ReturnType<C>[];
-    /**
-     * Balancing Adjustment:
-     * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.
-     * AVL Tree: After insertion or deletion operations, an AVL tree performs rotation adjustments based on the balance factor of nodes to restore the tree's balance. These rotations can be left rotations, right rotations, left-right rotations, or right-left rotations, performed as needed.
-     *
-     * Use Cases and Efficiency:
-     * Perfectly Balanced Binary Tree: Perfectly balanced binary trees are typically used in specific scenarios such as complete binary heaps in heap sort or certain types of Huffman trees. However, they are not suitable for dynamic operations requiring frequent insertions and deletions, as these operations often necessitate full tree reconstruction.
-     * AVL Tree: AVL trees are well-suited for scenarios involving frequent searching, insertion, and deletion operations. Through rotation adjustments, AVL trees maintain their balance, ensuring average and worst-case time complexity of O(log n).
-     */
+    lesserOrGreaterTraverse<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BSTNodeKeyOrNode<N>, iterationType?: IterationType): ReturnType<C>[];
     /**
-     * Time Complexity: O(n) - Building a balanced tree from a sorted array.
-     * Space Complexity: O(n) - Additional space is required for the sorted array.
+     * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
+     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
      */
     /**
      * Time Complexity: O(n) - Building a balanced tree from a sorted array.
@@ -225,10 +226,19 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * values:
      * @returns The function `perfectlyBalance` returns a boolean value.
      */
-    perfectlyBalance(iterationType?: IterationType | undefined): boolean;
+    perfectlyBalance(iterationType?: IterationType): boolean;
     /**
-     * Time Complexity: O(n) - Visiting each node once.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Balancing Adjustment:
+     * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.
+     * AVL Tree: After insertion or deletion operations, an AVL tree performs rotation adjustments based on the balance factor of nodes to restore the tree's balance. These rotations can be left rotations, right rotations, left-right rotations, or right-left rotations, performed as needed.
+     *
+     * Use Cases and Efficiency:
+     * Perfectly Balanced Binary Tree: Perfectly balanced binary trees are typically used in specific scenarios such as complete binary heaps in heap sort or certain types of Huffman trees. However, they are not suitable for dynamic operations requiring frequent insertions and deletions, as these operations often necessitate full tree reconstruction.
+     * AVL Tree: AVL trees are well-suited for scenarios involving frequent searching, insertion, and deletion operations. Through rotation adjustments, AVL trees maintain their balance, ensuring average and worst-case time complexity of O(log n).
+     */
+    /**
+     * Time Complexity: O(n) - Building a balanced tree from a sorted array.
+     * Space Complexity: O(n) - Additional space is required for the sorted array.
      */
     /**
      * Time Complexity: O(n) - Visiting each node once.
@@ -239,7 +249,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * to check if the AVL tree is balanced. It can have two possible values:
      * @returns a boolean value.
      */
-    isAVLBalanced(iterationType?: IterationType | undefined): boolean;
+    isAVLBalanced(iterationType?: IterationType): boolean;
     protected _setRoot(v: N | undefined): void;
     /**
      * The function compares two values using a comparator function and returns whether the first value