min-heap-typed 1.42.3 → 1.42.4

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

@@ -34,13 +34,13 @@ export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<
     /**
      * The function overrides the add method of a binary tree node and balances the tree after inserting
      * a new node.
-     * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can accept either a
+     * @param {BTNKey | N | undefined} keyOrNode - The `keyOrNode` parameter can accept either a
      * `BTNKey` or a `N` (which represents a node in the binary tree) or `null`.
      * @param [value] - The `value` parameter is the value that you want to assign to the new node that you
      * are adding to the binary search tree.
      * @returns The method is returning the inserted node (`N`), `null`, or `undefined`.
      */
-    add(keyOrNode: BTNKey | N | null, value?: V): N | null | undefined;
+    add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | undefined;
     /**
      * The function overrides the delete method of a binary tree and balances the tree after deleting a
      * node if necessary.

package/dist/data-structures/binary-tree/avl-tree.js

@@ -41,13 +41,15 @@ class AVLTree extends bst_1.BST {
     /**
      * The function overrides the add method of a binary tree node and balances the tree after inserting
      * a new node.
-     * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can accept either a
+     * @param {BTNKey | N | undefined} keyOrNode - The `keyOrNode` parameter can accept either a
      * `BTNKey` or a `N` (which represents a node in the binary tree) or `null`.
      * @param [value] - The `value` parameter is the value that you want to assign to the new node that you
      * are adding to the binary search tree.
      * @returns The method is returning the inserted node (`N`), `null`, or `undefined`.
      */
     add(keyOrNode, value) {
+        if (keyOrNode === null)
+            return undefined;
         const inserted = super.add(keyOrNode, value);
         if (inserted)
             this._balancePath(inserted);
@@ -217,7 +219,7 @@ class AVLTree extends bst_1.BST {
     _balanceLR(A) {
         const parentOfA = A.parent;
         const B = A.left;
-        let C = null;
+        let C = undefined;
         if (B) {
             C = B.right;
         }
@@ -301,7 +303,7 @@ class AVLTree extends bst_1.BST {
     _balanceRL(A) {
         const parentOfA = A.parent;
         const B = A.right;
-        let C = null;
+        let C = undefined;
         if (B) {
             C = B.left;
         }

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

@@ -69,11 +69,11 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options?: BinaryTreeOptions);
-    protected _root: N | null;
+    protected _root: N | null | undefined;
     /**
      * Get the root node of the binary tree.
      */
-    get root(): N | null;
+    get root(): N | null | undefined;
     protected _size: number;
     /**
      * Get the number of nodes in the binary tree.
@@ -101,7 +101,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @param {V} value - The value for the new node (optional).
      * @returns {N | null | undefined} - The inserted node, or null if nothing was inserted, or undefined if the operation failed.
      */
-    add(keyOrNode: BTNKey | N | null, value?: V): N | null | undefined;
+    add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | null | undefined;
     /**
      * The `addMany` function takes an array of binary tree node IDs or nodes, and optionally an array of corresponding data
      * values, and adds them to the binary tree.
@@ -112,7 +112,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * the value of the nodes will be `undefined`.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(keysOrNodes: (BTNKey | null)[] | (N | null)[], values?: V[]): (N | null | undefined)[];
+    addMany(keysOrNodes: (BTNKey | null | undefined)[] | (N | null | undefined)[], values?: V[]): (N | null | undefined)[];
     /**
      * The `refill` function clears the binary tree and adds multiple nodes with the given IDs or nodes and optional data.
      * @param {(BTNKey | N)[]} keysOrNodes - The `keysOrNodes` parameter is an array that can contain either
@@ -122,27 +122,27 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * array. Each value in the `data` array will be assigned to the
      * @returns The method is returning a boolean value.
      */
-    refill(keysOrNodes: (BTNKey | null)[] | (N | null)[], data?: Array<V>): boolean;
+    refill(keysOrNodes: (BTNKey | null | undefined)[] | (N | null | undefined)[], data?: Array<V>): boolean;
     delete<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C): BinaryTreeDeletedResult<N>[];
-    delete<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C): BinaryTreeDeletedResult<N>[];
+    delete<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C): BinaryTreeDeletedResult<N>[];
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C): BinaryTreeDeletedResult<N>[];
     /**
      * The function `getDepth` calculates the depth of a given node in a binary tree relative to a
      * specified root node.
-     * @param {BTNKey | N | null} distNode - The `distNode` parameter represents the node
+     * @param {BTNKey | N | null | undefined} distNode - The `distNode` parameter represents the node
      * whose depth we want to find in the binary tree. It can be either a node object (`N`), a key value
      * of the node (`BTNKey`), or `null`.
-     * @param {BTNKey | N | null} beginRoot - The `beginRoot` parameter represents the
+     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node from which we want to calculate the depth. It can be either a node object or the key
      * of a node in the binary tree. If no value is provided for `beginRoot`, it defaults to the root
      * node of the binary tree.
      * @returns the depth of the `distNode` relative to the `beginRoot`.
      */
-    getDepth(distNode: BTNKey | N | null, beginRoot?: BTNKey | N | null): number;
+    getDepth(distNode: BTNKey | N | null | undefined, beginRoot?: BTNKey | N | null | undefined): number;
     /**
      * The `getHeight` function calculates the maximum height of a binary tree using either recursive or
      * iterative approach.
-     * @param {BTNKey | N | null} beginRoot - The `beginRoot` parameter represents the
+     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node from which the height of the binary tree is calculated. It can be either a node
      * object (`N`), a key value of a node in the tree (`BTNKey`), or `null` if no starting
      * node is specified. If `
@@ -151,38 +151,38 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * possible values:
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot?: BTNKey | N | null, iterationType?: IterationType): number;
+    getHeight(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): number;
     /**
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach.
-     * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node from which we want to
+     * @param {N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node from which we want to
      * calculate the minimum height of the tree. It is optional and defaults to the root of the tree if
      * not provided.
      * @param iterationType - The `iterationType` parameter is used to determine the method of iteration
      * to calculate the minimum height of a binary tree. It can have two possible values:
      * @returns The function `getMinHeight` returns the minimum height of a binary tree.
      */
-    getMinHeight(beginRoot?: N | null, iterationType?: IterationType): number;
+    getMinHeight(beginRoot?: N | null | undefined, iterationType?: IterationType): number;
     /**
      * The function checks if a binary tree is perfectly balanced by comparing the minimum height and the
      * height of the tree.
-     * @param {N | null} beginRoot - The parameter `beginRoot` is of type `N | null`, which means it can
+     * @param {N | null | undefined} beginRoot - The parameter `beginRoot` is of type `N | null | undefined`, which means it can
      * either be of type `N` (representing a node in a tree) or `null` (representing an empty tree).
      * @returns The method is returning a boolean value.
      */
-    isPerfectlyBalanced(beginRoot?: N | null): boolean;
-    getNodes<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
-    getNodes<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
-    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
-    has<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null, iterationType?: IterationType): boolean;
-    has<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): boolean;
-    has<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C, beginRoot?: N | null, iterationType?: IterationType): boolean;
-    getNode<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
-    getNode<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
-    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
-    get<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null, iterationType?: IterationType): V | undefined;
-    get<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): V | undefined;
-    get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | null, iterationType?: IterationType): V | undefined;
+    isPerfectlyBalanced(beginRoot?: N | null | undefined): boolean;
+    getNodes<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, onlyOne?: boolean, beginRoot?: N | null | undefined, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, onlyOne?: boolean, beginRoot?: N | null | undefined, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: N | null | undefined, iterationType?: IterationType): N[];
+    has<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback: C, beginRoot?: N | null | undefined, iterationType?: IterationType): boolean;
+    getNode<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType): N | null | undefined;
+    getNode<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType): N | null | undefined;
+    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | null | undefined, iterationType?: IterationType): N | null | undefined;
+    get<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | null | undefined, iterationType?: IterationType): V | undefined;
     /**
      * The function `getPathToRoot` returns an array of nodes starting from a given node and traversing
      * up to the root node, with the option to reverse the order of the nodes.
@@ -197,7 +197,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     /**
      * The function `getLeftMost` returns the leftmost node in a binary tree, either using recursive or
      * iterative traversal.
-     * @param {BTNKey | N | null} beginRoot - The `beginRoot` parameter is the starting point
+     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
      * for finding the leftmost node in a binary tree. It can be either a node object (`N`), a key value
      * of a node (`BTNKey`), or `null` if the tree is empty.
      * @param iterationType - The `iterationType` parameter is used to determine the type of iteration to
@@ -205,19 +205,19 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns The function `getLeftMost` returns the leftmost node (`N`) in a binary tree. If there is
      * no leftmost node, it returns `null`.
      */
-    getLeftMost(beginRoot?: BTNKey | N | null, iterationType?: IterationType): N | null;
+    getLeftMost(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): N | null | undefined;
     /**
      * The function `getRightMost` returns the rightmost node in a binary tree, either recursively or
      * iteratively.
-     * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node from which we want to
-     * find the rightmost node. It is of type `N | null`, which means it can either be a node of type `N`
+     * @param {N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node from which we want to
+     * find the rightmost node. It is of type `N | null | undefined`, which means it can either be a node of type `N`
      * or `null`. If it is `null`, it means there is no starting node
      * @param iterationType - The `iterationType` parameter is used to determine the type of iteration to
      * be performed when finding the rightmost node in a binary tree. It can have two possible values:
      * @returns The function `getRightMost` returns the rightmost node (`N`) in a binary tree. If the
      * `beginRoot` parameter is `null`, it returns `null`.
      */
-    getRightMost(beginRoot?: N | null, iterationType?: IterationType): N | null;
+    getRightMost(beginRoot?: N | null | undefined, iterationType?: IterationType): N | null | undefined;
     /**
      * The function `isSubtreeBST` checks if a given binary tree is a valid binary search tree.
      * @param {N} beginRoot - The `beginRoot` parameter is the root node of the binary tree that you want
@@ -227,7 +227,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * possible values:
      * @returns The function `isSubtreeBST` returns a boolean value.
      */
-    isSubtreeBST(beginRoot: N | null, iterationType?: IterationType): boolean;
+    isSubtreeBST(beginRoot: N | null | undefined, iterationType?: IterationType): boolean;
     /**
      * The function checks if a binary tree is a binary search tree.
      * @param iterationType - The parameter "iterationType" is used to specify the type of iteration to
@@ -237,18 +237,21 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns a boolean value.
      */
     isBST(iterationType?: IterationType): boolean;
-    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    subTreeTraverse<C extends BTNCallback<N | null>>(callback?: C, beginRoot?: BTNKey | N | null, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
-    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    dfs<C extends BTNCallback<N | null>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
-    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    bfs<C extends BTNCallback<N | null>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
-    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
-    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[][];
-    listLevels<C extends BTNCallback<N | null>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
+    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
+    subTreeTraverse<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    isNode(node: any): node is N;
+    isNIL(node: any): boolean;
+    isNodeOrNull(node: any): node is (N | null);
+    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
+    dfs<C extends BTNCallback<N | null | undefined>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
+    bfs<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
     /**
      * The function returns the predecessor node of a given node in a binary tree.
      * @param {N} node - The parameter "node" represents a node in a binary tree.
@@ -272,12 +275,12 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter in the `morris` function
      * determines the order in which the nodes of a binary tree are traversed. It can have one of the
      * following values:
-     * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the Morris
+     * @param {N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node for the Morris
      * traversal. It specifies the root node of the tree from which the traversal should begin. If
      * `beginRoot` is `null`, an empty array will be returned.
      * @returns The `morris` function returns an array of `ReturnType<BTNCallback<N>>` values.
      */
-    morris<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null): ReturnType<C>[];
+    morris<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null | undefined): ReturnType<C>[];
     /**
      * The above function is an iterator for a binary tree that can be used to traverse the tree in
      * either an iterative or recursive manner.
@@ -287,7 +290,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns The `*[Symbol.iterator]` method returns a generator object that yields the keys of the
      * binary tree nodes in a specific order.
      */
-    [Symbol.iterator](node?: N | null): Generator<BTNKey, void, undefined>;
+    [Symbol.iterator](node?: N | null | undefined): Generator<BTNKey, void, undefined>;
     protected defaultOneParamCallback: (node: N) => number;
     /**
      * Swap the data of two nodes in the binary tree.
@@ -298,7 +301,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     protected _swap(srcNode: N, destNode: N): N;
     /**
      * The function `_addTo` adds a new node to a binary tree if there is an available position.
-     * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to
+     * @param {N | null | undefined} newNode - The `newNode` parameter represents the node that you want to add to
      * the binary tree. It can be either a node object or `null`.
      * @param {N} parent - The `parent` parameter represents the parent node to which the new node will
      * be added as a child.
@@ -307,12 +310,13 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * the binary tree. If neither the left nor right child is available, the function returns undefined.
      * If the parent node is null, the function also returns undefined.
      */
-    protected _addTo(newNode: N | null, parent: N): N | null | undefined;
+    protected _addTo(newNode: N | null | undefined, parent: N): N | null | undefined;
     /**
      * The function sets the root property of an object to a given value, and if the value is not null,
      * it also sets the parent property of the value to undefined.
-     * @param {N | null} v - The parameter `v` is of type `N | null`, which means it can either be of
+     * @param {N | null | undefined} v - The parameter `v` is of type `N | null | undefined`, which means it can either be of
      * type `N` or `null`.
      */
-    protected _setRoot(v: N | null): void;
+    protected _setRoot(v: N | null | undefined): void;
+    print(beginRoot?: N | null | undefined): void;
 }