doubly-linked-list-typed/dist/data-structures/binary-tree/binary-tree.d.ts

Doubly Linked List

/**
 * data-structure-typed
 *
 * @author Pablo Zeng
 * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
 * @license MIT License
 */
import type { BinaryTreeDeleteResult, BinaryTreeOptions, BinaryTreePrintOptions, BTNEntry, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, NodeCallback, NodeDisplayLayout, NodePredicate, OptNodeOrNull, RBTNColor, ToEntryFn } from '../../types';
import { IBinaryTree } from '../../interfaces';
import { IterableEntryBase } from '../base';
import { Range } from '../../common';
/**
 * Represents a node in a binary tree.
 * @template V - The type of data stored in the node.
 * @template BinaryTreeNode<K, V> - The type of the family relationship in the binary tree.
 */
export declare class BinaryTreeNode<K = any, V = any> {
    key: K;
    value?: V;
    parent?: BinaryTreeNode<K, V>;
    /**
     * The constructor function initializes an object with a key and an optional value in TypeScript.
     * @param {K} key - The `key` parameter in the constructor function is used to store the key value
     * for the key-value pair.
     * @param {V} [value] - The `value` parameter in the constructor is optional, meaning it does not
     * have to be provided when creating an instance of the class. If a `value` is not provided, it will
     * default to `undefined`.
     */
    constructor(key: K, value?: V);
    _left?: BinaryTreeNode<K, V> | null | undefined;
    get left(): BinaryTreeNode<K, V> | null | undefined;
    set left(v: BinaryTreeNode<K, V> | null | undefined);
    _right?: BinaryTreeNode<K, V> | null | undefined;
    get right(): BinaryTreeNode<K, V> | null | undefined;
    set right(v: BinaryTreeNode<K, V> | null | undefined);
    _height: number;
    get height(): number;
    set height(value: number);
    _color: RBTNColor;
    get color(): RBTNColor;
    set color(value: RBTNColor);
    _count: number;
    get count(): number;
    set count(value: number);
    get familyPosition(): FamilyPosition;
}
/**
 * 1. Two Children Maximum: Each node has at most two children.
 * 2. Left and Right Children: Nodes have distinct left and right children.
 * 3. Depth and Height: Depth is the number of edges from the root to a node; height is the maximum depth in the tree.
 * 4. Subtrees: Each child of a node forms the root of a subtree.
 * 5. Leaf Nodes: Nodes without children are leaves.
 * @example
 * // determine loan approval using a decision tree
 *     // Decision tree structure
 *     const loanDecisionTree = new BinaryTree<string>(
 *       ['stableIncome', 'goodCredit', 'Rejected', 'Approved', 'Rejected'],
 *       { isDuplicate: true }
 *     );
 *
 *     function determineLoanApproval(
 *       node?: BinaryTreeNode<string> | null,
 *       conditions?: { [key: string]: boolean }
 *     ): string {
 *       if (!node) throw new Error('Invalid node');
 *
 *       // If it's a leaf node, return the decision result
 *       if (!node.left && !node.right) return node.key;
 *
 *       // Check if a valid condition exists for the current node's key
 *       return conditions?.[node.key]
 *         ? determineLoanApproval(node.left, conditions)
 *         : determineLoanApproval(node.right, conditions);
 *     }
 *
 *     // Test case 1: Stable income and good credit score
 *     console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: true, goodCredit: true })); // 'Approved'
 *
 *     // Test case 2: Stable income but poor credit score
 *     console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: true, goodCredit: false })); // 'Rejected'
 *
 *     // Test case 3: No stable income
 *     console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: false, goodCredit: true })); // 'Rejected'
 *
 *     // Test case 4: No stable income and poor credit score
 *     console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: false, goodCredit: false })); // 'Rejected'
 * @example
 * // evaluate the arithmetic expression represented by the binary tree
 *     const expressionTree = new BinaryTree<number | string>(['+', 3, '*', null, null, 5, '-', null, null, 2, 8]);
 *
 *     function evaluate(node?: BinaryTreeNode<number | string> | null): number {
 *       if (!node) return 0;
 *
 *       if (typeof node.key === 'number') return node.key;
 *
 *       const leftValue = evaluate(node.left); // Evaluate the left subtree
 *       const rightValue = evaluate(node.right); // Evaluate the right subtree
 *
 *       // Perform the operation based on the current node's operator
 *       switch (node.key) {
 *         case '+':
 *           return leftValue + rightValue;
 *         case '-':
 *           return leftValue - rightValue;
 *         case '*':
 *           return leftValue * rightValue;
 *         case '/':
 *           return rightValue !== 0 ? leftValue / rightValue : 0; // Handle division by zero
 *         default:
 *           throw new Error(`Unsupported operator: ${node.key}`);
 *       }
 *     }
 *
 *     console.log(evaluate(expressionTree.root)); // -27
 */
export declare class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = object> extends IterableEntryBase<K, V | undefined> implements IBinaryTree<K, V, R, MK, MV, MR> {
    iterationType: IterationType;
    /**
     * This TypeScript constructor function initializes a binary tree with optional options and adds
     * elements based on the provided input.
     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
     * iterable that can contain either objects of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It
     * is used to initialize the binary tree with keys, nodes, entries, or raw data.
     * @param [options] - The `options` parameter in the constructor is an optional object that can
     * contain the following properties:
     */
    constructor(keysNodesEntriesOrRaws?: Iterable<K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, options?: BinaryTreeOptions<K, V, R>);
    protected _isMapMode: boolean;
    get isMapMode(): boolean;
    protected _isDuplicate: boolean;
    get isDuplicate(): boolean;
    protected _store: Map<K, V | undefined>;
    get store(): Map<K, V | undefined>;
    protected _root?: BinaryTreeNode<K, V> | null | undefined;
    get root(): BinaryTreeNode<K, V> | null | undefined;
    protected _size: number;
    get size(): number;
    protected _NIL: BinaryTreeNode<K, V>;
    get NIL(): BinaryTreeNode<K, V>;
    protected _toEntryFn?: ToEntryFn<K, V, R>;
    get toEntryFn(): ToEntryFn<K, V, R> | undefined;
    /**
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     *
     * The function creates a new binary tree node with a specified key and optional value.
     * @param {K} key - The `key` parameter is the key of the node being created in the binary tree.
     * @param {V} [value] - The `value` parameter in the `createNode` function is optional, meaning it is
     * not required to be provided when calling the function. If a `value` is provided, it should be of
     * type `V`, which is the type of the value associated with the node.
     * @returns A new BinaryTreeNode instance with the provided key and value is being returned, casted
     * as BinaryTreeNode<K, V>.
     */
    createNode(key: K, value?: V): BinaryTreeNode<K, V>;
    /**
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     *
     * The function creates a binary tree with the specified options.
     * @param [options] - The `options` parameter in the `createTree` function is an optional parameter
     * that allows you to provide partial configuration options for creating a binary tree. It is of type
     * `Partial<BinaryTreeOptions<K, V, R>>`, which means you can pass in an object containing a subset
     * of properties
     * @returns A new instance of a binary tree with the specified options is being returned.
     */
    createTree(options?: BinaryTreeOptions<K, V, R>): BinaryTree<K, V, R, MK, MV, MR>;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(log n)
     *
     * The function `ensureNode` in TypeScript checks if a given input is a node, entry, key, or raw
     * value and returns the corresponding node or null.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `keyNodeOrEntry`
     * parameter in the `ensureNode` function can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It
     * is used to determine whether the input is a key, node, entry, or raw data. The
     * @param {IterationType} iterationType - The `iterationType` parameter in the `ensureNode` function
     * is used to specify the type of iteration to be performed. It has a default value of
     * `this.iterationType` if not explicitly provided.
     * @returns The `ensureNode` function returns either a node, `null`, or `undefined` based on the
     * conditions specified in the code snippet.
     */
    ensureNode(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): BinaryTreeNode<K, V> | null | undefined;
    /**
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     *
     * The function isNode checks if the input is an instance of BinaryTreeNode.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
     * `keyNodeOrEntry` can be either a key, a node, an entry, or raw data. The function is
     * checking if the input is an instance of a `BinaryTreeNode` and returning a boolean value
     * accordingly.
     * @returns The function `isNode` is checking if the input `keyNodeOrEntry` is an instance of
     * `BinaryTreeNode`. If it is, the function returns `true`, indicating that the input is a node. If
     * it is not an instance of `BinaryTreeNode`, the function returns `false`, indicating that the input
     * is not a node.
     */
    isNode(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): keyNodeOrEntry is BinaryTreeNode<K, V>;
    /**
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     *
     * The function `isRaw` checks if the input parameter is of type `R` by verifying if it is an object.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | R} keyNodeEntryOrRaw - K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
     * @returns The function `isRaw` is checking if the `keyNodeEntryOrRaw` parameter is of type `R` by
     * checking if it is an object. If the parameter is an object, the function will return `true`,
     * indicating that it is of type `R`.
     */
    isRaw(keyNodeEntryOrRaw: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R): keyNodeEntryOrRaw is R;
    /**
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     *
     * The function `isRealNode` checks if a given input is a valid node in a binary tree.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `keyNodeOrEntry`
     * parameter in the `isRealNode` function can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`.
     * The function checks if the input parameter is a `BinaryTreeNode<K, V>` type by verifying if it is not equal
     * @returns The function `isRealNode` is checking if the input `keyNodeOrEntry` is a valid
     * node by comparing it to `this._NIL`, `null`, and `undefined`. If the input is not one of these
     * values, it then calls the `isNode` method to further determine if the input is a node. The
     * function will return a boolean value indicating whether the
     */
    isRealNode(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): keyNodeOrEntry is BinaryTreeNode<K, V>;
    /**
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     *
     * The function checks if a given input is a valid node or null.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
     * `keyNodeOrEntry` in the `isRealNodeOrNull` function can be of type `BTNRep<K,
     * V, BinaryTreeNode<K, V>>` or `R`. It is a union type that can either be a key, a node, an entry, or
     * @returns The function `isRealNodeOrNull` is returning a boolean value. It checks if the input
     * `keyNodeOrEntry` is either `null` or a real node, and returns `true` if it is a node or
     * `null`, and `false` otherwise.
     */
    isRealNodeOrNull(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): keyNodeOrEntry is BinaryTreeNode<K, V> | null;
    /**
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     *
     * The function isNIL checks if a given key, node, entry, or raw value is equal to the _NIL value.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - BTNRep<K, V,
     * BinaryTreeNode<K, V>>
     * @returns The function is checking if the `keyNodeOrEntry` parameter is equal to the `_NIL`
     * property of the current object and returning a boolean value based on that comparison.
     */
    isNIL(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): boolean;
    /**
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     *
     * The function `isRange` checks if the input parameter is an instance of the `Range` class.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>> | Range<K>} keyNodeEntryOrPredicate
     * - The `keyNodeEntryOrPredicate` parameter in the `isRange` function can be
     * of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `, `NodePredicate<BinaryTreeNode<K, V>>`, or
     * `Range<K>`. The function checks if the `keyNodeEntry
     * @returns The `isRange` function is checking if the `keyNodeEntryOrPredicate` parameter is an
     * instance of the `Range` class. If it is an instance of `Range`, the function will return `true`,
     * indicating that the parameter is a `Range<K>`. If it is not an instance of `Range`, the function
     * will return `false`.
     */
    isRange(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V>> | Range<K>): keyNodeEntryOrPredicate is Range<K>;
    /**
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     *
     * The function determines whether a given key, node, entry, or raw data is a leaf node in a binary
     * tree.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
     * `keyNodeOrEntry` can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It represents a
     * key, node, entry, or raw data in a binary tree structure. The function `isLeaf` checks whether the
     * provided
     * @returns The function `isLeaf` returns a boolean value indicating whether the input
     * `keyNodeOrEntry` is a leaf node in a binary tree.
     */
    isLeaf(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): boolean;
    /**
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     *
     * The function `isEntry` checks if the input is a BTNEntry object by verifying if it is an array
     * with a length of 2.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `keyNodeOrEntry`
     * parameter in the `isEntry` function can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or type `R`.
     * The function checks if the provided `keyNodeOrEntry` is of type `BTN
     * @returns The `isEntry` function is checking if the `keyNodeOrEntry` parameter is an array
     * with a length of 2. If it is, then it returns `true`, indicating that the parameter is of type
     * `BTNEntry<K, V>`. If the condition is not met, it returns `false`.
     */
    isEntry(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): keyNodeOrEntry is BTNEntry<K, V>;
    /**
     * Time Complexity O(1)
     * Space Complexity O(1)
     *
     * The function `isValidKey` checks if a given key is comparable.
     * @param {any} key - The `key` parameter is of type `any`, which means it can be any data type in
     * TypeScript.
     * @returns The function `isValidKey` is checking if the `key` parameter is `null` or if it is comparable.
     * If the `key` is `null`, the function returns `true`. Otherwise, it returns the result of the
     * `isComparable` function, which is not provided in the code snippet.
     */
    isValidKey(key: any): key is K;
    /**
     * Time Complexity O(n)
     * Space Complexity O(1)
     *
     * The `add` function in TypeScript adds a new node to a binary tree while handling duplicate keys
     * and finding the correct insertion position.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `add` method you provided
     * seems to be for adding a new node to a binary tree structure. The `keyNodeOrEntry`
     * parameter in the method can accept different types of values:
     * @param {V} [value] - The `value` parameter in the `add` method represents the value associated
     * with the key that you want to add to the binary tree. When adding a key-value pair to the binary
     * tree, you provide the key and its corresponding value. The `add` method then creates a new node
     * with this
     * @returns The `add` method returns a boolean value. It returns `true` if the insertion of the new
     * node was successful, and `false` if the insertion position could not be found or if a duplicate
     * key was found and the node was replaced instead of inserted.
     */
    add(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V): boolean;
    /**
     * Time Complexity: O(k * n)
     * Space Complexity: O(k)
     *
     * The `addMany` function takes in multiple keys or nodes or entries or raw values along with
     * optional values, and adds them to a data structure while returning an array indicating whether
     * each insertion was successful.
     * @param keysNodesEntriesOrRaws - `keysNodesEntriesOrRaws` is an iterable that can contain a
     * mix of keys, nodes, entries, or raw values. Each element in this iterable can be of type
     * `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`.
     * @param [values] - The `values` parameter in the `addMany` function is an optional parameter that
     * accepts an iterable of values. These values correspond to the keys or nodes being added in the
     * `keysNodesEntriesOrRaws` parameter. If provided, the function will iterate over the values and
     * assign them
     * @returns The `addMany` method returns an array of boolean values indicating whether each key,
     * node, entry, or raw value was successfully added to the data structure. Each boolean value
     * corresponds to the success of adding the corresponding key or value in the input iterable.
     */
    addMany(keysNodesEntriesOrRaws: Iterable<K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, values?: Iterable<V | undefined>): boolean[];
    /**
     * Time Complexity: O(k * n)
     * Space Complexity: O(1)
     *
     * The `merge` function in TypeScript merges another binary tree into the current tree by adding all
     * elements from the other tree.
     * @param anotherTree - BinaryTree<K, V, R, MK, MV, MR>
     */
    merge(anotherTree: BinaryTree<K, V, R, MK, MV, MR>): void;
    /**
     * Time Complexity: O(k * n)
     * Space Complexity: O(1)
     *
     * The `refill` function clears the existing data structure and then adds new key-value pairs based
     * on the provided input.
     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the `refill`
     * method can accept an iterable containing a mix of `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` objects or `R`
     * objects.
     * @param [values] - The `values` parameter in the `refill` method is an optional parameter that
     * accepts an iterable of values of type `V` or `undefined`.
     */
    refill(keysNodesEntriesOrRaws: Iterable<K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, values?: Iterable<V | undefined>): void;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(1)
     *
     * The function `delete` in TypeScript implements the deletion of a node in a binary tree and returns
     * the deleted node along with information for tree balancing.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry
     * - The `delete` method you provided is used to delete a node from a binary tree based on the key,
     * node, entry or raw data. The method returns an array of
     * `BinaryTreeDeleteResult` objects containing information about the deleted node and whether
     * balancing is needed.
     * @returns The `delete` method returns an array of `BinaryTreeDeleteResult` objects. Each object in
     * the array contains information about the node that was deleted (`deleted`) and the node that may
     * need to be balanced (`needBalanced`).
     */
    delete(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[];
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(k + log n)
     *
     * The `search` function in TypeScript performs a depth-first or breadth-first search on a tree
     * structure based on a given predicate or key, with options to return multiple results or just one.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate - The
     * `keyNodeEntryOrPredicate` parameter in the `search` function can accept three types of values:
     * @param [onlyOne=false] - The `onlyOne` parameter in the `search` function is a boolean flag that
     * determines whether the search should stop after finding the first matching node. If `onlyOne` is
     * set to `true`, the search will return as soon as a matching node is found. If `onlyOne` is
     * @param {C} callback - The `callback` parameter in the `search` function is a callback function
     * that will be called on each node that matches the search criteria. It is of type `C`, which
     * extends `NodeCallback<BinaryTreeNode<K, V> | null>`. The default value for `callback` is `this._DEFAULT_NODE_CALLBACK` if
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `search` function is
     * used to specify the node from which the search operation should begin. It represents the starting
     * point in the binary tree where the search will be performed. If no specific `startNode` is
     * provided, the search operation will start from the root
     * @param {IterationType} iterationType - The `iterationType` parameter in the `search` function
     * specifies the type of iteration to be used when searching for nodes in a binary tree. It can have
     * two possible values:
     * @returns The `search` function returns an array of values that match the provided criteria based
     * on the search algorithm implemented within the function.
     */
    search<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V> | null>, onlyOne?: boolean, callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
    getNodes(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V>>, onlyOne?: boolean, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): BinaryTreeNode<K, V>[];
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(log n)
     *
     * The `getNode` function retrieves a node based on the provided key, node, entry, raw data, or
     * predicate.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
     * - The `keyNodeEntryOrPredicate` parameter in the `getNode` function can accept a key,
     * node, entry, raw data, or a predicate function.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
     * `getNode` function is used to specify the starting point for searching for a node in a binary
     * tree. If no specific starting point is provided, the default value is set to `this._root`, which
     * is typically the root node of the binary tree.
     * @param {IterationType} iterationType - The `iterationType` parameter in the `getNode` method is
     * used to specify the type of iteration to be performed when searching for a node. It has a default
     * value of `this.iterationType`, which means it will use the iteration type defined in the current
     * context if no specific value is provided
     * @returns The `getNode` function is returning the first node that matches the specified criteria,
     * or `null` if no matching node is found.
     */
    getNode(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V> | null>, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): BinaryTreeNode<K, V> | null | undefined;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(log n)
     *
     * This function overrides the `get` method to retrieve the value associated with a specified key,
     * node, entry, raw data, or predicate in a data structure.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
     * - The `keyNodeEntryOrPredicate` parameter in the `get` method can accept one of the
     * following types:
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `get`
     * method is used to specify the starting point for searching for a key or node in the binary tree.
     * If no specific starting point is provided, the default starting point is the root of the binary
     * tree (`this._root`).
     * @param {IterationType} iterationType - The `iterationType` parameter in the `get` method is used
     * to specify the type of iteration to be performed when searching for a key in the binary tree. It
     * is an optional parameter with a default value of `this.iterationType`, which means it will use the
     * iteration type defined in the
     * @returns The `get` method is returning the value associated with the specified key, node, entry,
     * raw data, or predicate in the binary tree map. If the specified key or node is found in the tree,
     * the method returns the corresponding value. If the key or node is not found, it returns
     * `undefined`.
     */
    get(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): V | undefined;
    has(keyNodeEntryOrPredicate?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V>>, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): boolean;
    /**
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     *
     * The clear function removes nodes and values in map mode.
     */
    clear(): void;
    /**
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     *
     * The `isEmpty` function in TypeScript checks if a data structure has no elements and returns a
     * boolean value.
     * @returns The `isEmpty()` method is returning a boolean value, specifically `true` if the `_size`
     * property is equal to 0, indicating that the data structure is empty, and `false` otherwise.
     */
    isEmpty(): boolean;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(log n)
     *
     * The function checks if a binary tree is perfectly balanced by comparing its minimum height with
     * its height.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter is the starting
     * point for checking if the binary tree is perfectly balanced. It represents the root node of the
     * binary tree or a specific node from which the balance check should begin.
     * @returns The method `isPerfectlyBalanced` is returning a boolean value, which indicates whether
     * the tree starting from the `startNode` node is perfectly balanced or not. The return value is
     * determined by comparing the minimum height of the tree with the height of the tree. If the minimum
     * height plus 1 is greater than or equal to the height of the tree, then it is considered perfectly
     * balanced and
     */
    isPerfectlyBalanced(startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): boolean;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(log n)
     *
     * The function `isBST` in TypeScript checks if a binary search tree is valid using either recursive
     * or iterative methods.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `isBST`
     * function represents the starting point for checking whether a binary search tree (BST) is valid.
     * It can be a node in the BST or a reference to the root of the BST. If no specific node is
     * provided, the function will default to
     * @param {IterationType} iterationType - The `iterationType` parameter in the `isBST` function
     * determines whether the function should use a recursive approach or an iterative approach to check
     * if the binary search tree (BST) is valid.
     * @returns The `isBST` method is returning a boolean value, which indicates whether the binary
     * search tree (BST) represented by the given root node is a valid BST or not. The method checks if
     * the tree satisfies the BST property, where for every node, all nodes in its left subtree have keys
     * less than the node's key, and all nodes in its right subtree have keys greater than the node's
     */
    isBST(startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): boolean;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(log n)
     *
     * The `getDepth` function calculates the depth between two nodes in a binary tree.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } dist - The `dist` parameter in the `getDepth`
     * function represents the node or entry in a binary tree map, or a reference to a node in the tree.
     * It is the target node for which you want to calculate the depth from the `startNode` node.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
     * `getDepth` function represents the starting point from which you want to calculate the depth of a
     * given node or entry in a binary tree. If no specific starting point is provided, the default value
     * for `startNode` is set to the root of the binary
     * @returns The `getDepth` method returns the depth of a given node `dist` relative to the
     * `startNode` node in a binary tree. If the `dist` node is not found in the path to the `startNode`
     * node, it returns the depth of the `dist` node from the root of the tree.
     */
    getDepth(dist: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): number;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(log n)
     *
     * The `getHeight` function calculates the maximum height of a binary tree using either a recursive
     * or iterative approach in TypeScript.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter is the starting
     * point from which the height of the binary tree will be calculated. It can be a node in the binary
     * tree or a reference to the root of the tree. If not provided, it defaults to the root of the
     * binary tree data structure.
     * @param {IterationType} iterationType - The `iterationType` parameter is used to determine the type
     * of iteration to be performed while calculating the height of the binary tree. It can have two
     * possible values:
     * @returns The `getHeight` method returns the height of the binary tree starting from the specified
     * root node. The height is calculated based on the maximum depth of the tree, considering either a
     * recursive approach or an iterative approach depending on the `iterationType` parameter.
     */
    getHeight(startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): number;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(log n)
     *
     * The `getMinHeight` function calculates the minimum height of a binary tree using either a
     * recursive or iterative approach in TypeScript.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
     * `getMinHeight` function represents the starting node from which the minimum height of the binary
     * tree will be calculated. It is either a node in the binary tree or a reference to the root of the
     * tree. If not provided, the default value is the root
     * @param {IterationType} iterationType - The `iterationType` parameter in the `getMinHeight` method
     * specifies the type of iteration to use when calculating the minimum height of a binary tree. It
     * can have two possible values:
     * @returns The `getMinHeight` method returns the minimum height of the binary tree starting from the
     * specified root node. The height is calculated based on the shortest path from the root node to a
     * leaf node in the tree. The method uses either a recursive approach or an iterative approach (using
     * a stack) based on the `iterationType` parameter.
     */
    getMinHeight(startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): number;
    /**
     * Time Complexity: O(log n)
     * Space Complexity: O(log n)
     *
     * The function `getPathToRoot` in TypeScript retrieves the path from a given node to the root of a
     * tree structure, applying a specified callback function along the way.
     * @param {C} callback - The `callback` parameter is a function that is used to process each node in
     * the path to the root. It is expected to be a function that takes a node as an argument and returns
     * a value based on that node. The return type of the callback function is determined by the generic
     * type `C
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } beginNode - The `beginNode` parameter in the
     * `getPathToRoot` function can be either a key, a node, an entry, or any other value of type `R`.
     * @param [isReverse=true] - The `isReverse` parameter in the `getPathToRoot` function determines
     * whether the resulting path from the given `beginNode` to the root should be in reverse order or
     * not. If `isReverse` is set to `true`, the path will be reversed before being returned. If `is
     * @returns The function `getPathToRoot` returns an array of the return values of the callback
     * function `callback` applied to each node in the path from the `beginNode` to the root node. The
     * array is either in reverse order or in the original order based on the value of the `isReverse`
     * parameter.
     */
    getPathToRoot<C extends NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>>(beginNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, callback?: C, isReverse?: boolean): ReturnType<C>[];
    /**
     * Time Complexity: O(log n)
     * Space Complexity: O(log n)
     *
     * The function `getLeftMost` retrieves the leftmost node in a binary tree using either recursive or
     * tail-recursive iteration.
     * @param {C} callback - The `callback` parameter is a function that will be called with the leftmost
     * node of a binary tree or with `undefined` if the tree is empty. It is provided with a default
     * value of `_DEFAULT_NODE_CALLBACK` if not specified.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
     * `getLeftMost` function represents the starting point for finding the leftmost node in a binary
     * tree. It can be either a key, a node, or an entry in the binary tree structure. If no specific
     * starting point is provided, the function will default
     * @param {IterationType} iterationType - The `iterationType` parameter in the `getLeftMost` function
     * specifies the type of iteration to be used when traversing the binary tree nodes. It can have two
     * possible values:
     * @returns The `getLeftMost` function returns the result of the callback function `C` applied to the
     * leftmost node in the binary tree starting from the `startNode` node. If the `startNode` node is
     * `NIL`, it returns the result of the callback function applied to `undefined`. If the `startNode`
     * node is not a real node, it returns the result of the callback
     */
    getLeftMost<C extends NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>;
    /**
     * Time Complexity: O(log n)
     * Space Complexity: O(log n)
     *
     * The function `getRightMost` retrieves the rightmost node in a binary tree using either recursive
     * or iterative traversal methods.
     * @param {C} callback - The `callback` parameter is a function that will be called with the result
     * of finding the rightmost node in a binary tree. It is of type `NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>`,
     * which means it is a callback function that can accept either an optional binary tree node or null
     * as
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
     * `getRightMost` function represents the starting point for finding the rightmost node in a binary
     * tree. It can be either a key, a node, or an entry in the binary tree structure. If no specific
     * starting point is provided, the function will default
     * @param {IterationType} iterationType - The `iterationType` parameter in the `getRightMost`
     * function specifies the type of iteration to be used when traversing the binary tree nodes. It can
     * have two possible values:
     * @returns The `getRightMost` function returns the result of the callback function `C`, which is
     * passed as a parameter to the function. The callback function is called with the rightmost node in
     * the binary tree structure, determined based on the specified iteration type ('RECURSIVE' or
     * other).
     */
    getRightMost<C extends NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>;
    /**
     * Time Complexity: O(log n)
     * Space Complexity: O(log n)
     *
     * The function `getPredecessor` in TypeScript returns the predecessor node of a given node in a
     * binary tree.
     * @param {BinaryTreeNode<K, V>} node - The `getPredecessor` function you provided seems to be attempting to find the
     * predecessor of a given node in a binary tree. However, there seems to be a logical issue in the
     * while loop condition that might cause an infinite loop.
     * @returns The `getPredecessor` function returns the predecessor node of the input `BinaryTreeNode<K, V>` parameter.
     * If the left child of the input node exists, it traverses to the rightmost node of the left subtree
     * to find the predecessor. If the left child does not exist, it returns the input node itself.
     */
    getPredecessor(node: BinaryTreeNode<K, V>): BinaryTreeNode<K, V>;
    /**
     * Time Complexity: O(log n)
     * Space Complexity: O(log n)
     *
     * The function `getSuccessor` in TypeScript returns the next node in an in-order traversal of a
     * binary tree.
     * @param {K | BinaryTreeNode<K, V> | null} [x] - The `getSuccessor` function takes a parameter `x`, which can be of
     * type `K`, `BinaryTreeNode<K, V>`, or `null`.
     * @returns The `getSuccessor` function returns the successor node of the input node `x`. If `x` has
     * a right child, the function returns the leftmost node in the right subtree of `x`. If `x` does not
     * have a right child, the function traverses up the parent nodes until it finds a node that is not
     * the right child of its parent, and returns that node
     */
    getSuccessor(x?: K | BinaryTreeNode<K, V> | null): BinaryTreeNode<K, V> | null | undefined;
    dfs<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback?: C, pattern?: DFSOrderPattern, onlyOne?: boolean, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
    dfs<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(callback?: C, pattern?: DFSOrderPattern, onlyOne?: boolean, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: boolean): ReturnType<C>[];
    bfs<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
    bfs<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
    /**
     * Time complexity: O(n)
     * Space complexity: O(n)
     *
     * The `leaves` function in TypeScript returns an array of values from leaf nodes in a binary tree
     * structure based on a specified callback and iteration type.
     * @param {C} callback - The `callback` parameter is a function that will be called on each leaf node
     * in the binary tree. It is optional and defaults to a default callback function if not provided.
     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `leaves`
     * method is used to specify the starting point for finding and processing the leaves of a binary
     * tree. It can be provided as either a key, a node, or an entry in the binary tree structure. If not
     * explicitly provided, the default value
     * @param {IterationType} iterationType - The `iterationType` parameter in the `leaves` method
     * specifies the type of iteration to be performed when collecting the leaves of a binary tree. It
     * can have two possible values:
     * @returns The `leaves` method returns an array of values that are the result of applying the
     * provided callback function to each leaf node in the binary tree.
     */
    leaves<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
    listLevels<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
    listLevels<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
    morris<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback?: C, pattern?: DFSOrderPattern, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): ReturnType<C>[];
    /**
     * Time complexity: O(n)
     * Space complexity: O(n)
     *
     * The `clone` function creates a deep copy of a tree structure by traversing it using breadth-first
     * search.
     * @returns The `clone()` method is returning a cloned copy of the tree with the same structure and
     * values as the original tree. The method creates a new tree, iterates over the nodes of the
     * original tree using breadth-first search (bfs), and adds the nodes to the new tree. If a node in
     * the original tree is null, a null node is added to the cloned tree. If a node
     */
    clone(): BinaryTree<K, V, R, MK, MV, MR>;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(n)
     *
     * The `filter` function iterates over key-value pairs in a tree data structure and creates a new
     * tree with elements that satisfy a given predicate.
     * @param predicate - The `predicate` parameter in the `filter` method is a function that will be
     * called with four arguments: the `value` of the current entry, the `key` of the current entry, the
     * `index` of the current entry in the iteration, and the reference to the tree itself (`
     * @param {any} [thisArg] - The `thisArg` parameter in the `filter` method allows you to specify the
     * value of `this` that should be used when executing the `predicate` function. This is useful when
     * the `predicate` function relies on the context of a specific object or value. By providing a
     * `thisArg
     * @returns The `filter` method is returning a new tree that contains entries that pass the provided
     * predicate function.
     */
    filter(predicate: EntryCallback<K, V | undefined, boolean>, thisArg?: any): BinaryTree<K, V, R, MK, MV, MR>;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(n)
     *
     * The `map` function in TypeScript creates a new BinaryTree by applying a callback function to each
     * entry in the original BinaryTree.
     * @param callback - A function that will be called for each entry in the current binary tree. It
     * takes the key, value (which can be undefined), and an array containing the mapped key and value as
     * arguments.
     * @param [options] - The `options` parameter in the `map` method is of type `BinaryTreeOptions<MK,
     * MV, MR>`. It is an optional parameter that allows you to specify additional options for the binary
     * tree being created during the mapping process. These options could include things like custom
     * comparators, initial
     * @param {any} [thisArg] - The `thisArg` parameter in the `map` method is used to specify the value
     * of `this` when executing the `callback` function. It allows you to set the context (value of
     * `this`) within the callback function. If `thisArg` is provided, it will be passed
     * @returns The `map` function is returning a new `BinaryTree` instance filled with entries that are
     * the result of applying the provided `callback` function to each entry in the original tree.
     */
    map(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: BinaryTreeOptions<MK, MV, MR>, thisArg?: any): BinaryTree<MK, MV, MR>;
    /**
     * Time Complexity: O(n)
     * Space Complexity: O(n)
     *
     * The function `toVisual` in TypeScript overrides the visual representation of a binary tree with
     * customizable options f