Class BinaryTree<K, V, R, MK, MV, MR>

Two Children Maximum: Each node has at most two children.
Left and Right Children: Nodes have distinct left and right children.
Depth and Height: Depth is the number of edges from the root to a node; height is the maximum depth in the tree.
Subtrees: Each child of a node forms the root of a subtree.
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

Type Parameters

K = any
V = any
R = object
MK = any
MV = any
MR = object

Hierarchy (view full)

IterableEntryBase<K, V | undefined>
- BinaryTree
  - BST

Implements

IBinaryTree<K, V, R, MK, MV, MR>

Constructors

constructor

new BinaryTree<K, V, R, MK, MV, MR>(keysNodesEntriesOrRaws?, options?): BinaryTree<K, V, R, MK, MV, MR>
This TypeScript constructor function initializes a binary tree with optional options and adds elements based on the provided input.
Type Parameters
- K = any
- V = any
- R = object
- MK = any
- MV = any
- MR = object
Parameters
- keysNodesEntriesOrRaws: Iterable<
      | undefined
      | null
      | K
      | R
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V], any, any> = []
  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.
- Optionaloptions: BinaryTreeOptions<K, V, R>
  The options parameter in the constructor is an optional object that can contain the following properties:
Returns BinaryTree<K, V, R, MK, MV, MR>
Overrides IterableEntryBase<K, V | undefined>.constructor
- Defined in binary-tree/binary-tree.ts:210

Methods

`Protected`_clearNodes

_clearNodes(): void
Time Complexity: O(1) Space Complexity: O(1)

The _clearNodes function sets the root node to undefined and resets the size to 0.

Returns void
- Defined in binary-tree/binary-tree.ts:2528

`Protected`_clearValues

_clearValues(): void
Time Complexity: O(1) Space Complexity: O(1)

The _clearValues function clears all values stored in the _store object.

Returns void
- Defined in binary-tree/binary-tree.ts:2539

`Protected`_dfs

_dfs<C>(callback, pattern?, onlyOne?, startNode?, iterationType?, includeNull?, shouldVisitLeft?, shouldVisitRight?, shouldVisitRoot?, shouldProcessRoot?): ReturnType<C>[]
Type Parameters
- C extends NodeCallback<BinaryTreeNode<K, V>>
Parameters
- callback: C
  The callback parameter in the _dfs method is a function that will be called on each node visited during the depth-first search traversal. It is a generic type C that extends NodeCallback<BinaryTreeNode<K, V> | null>. The default value for callback
- Optionalpattern: DFSOrderPattern
  The pattern parameter in the _dfs method specifies the order in which the nodes are visited during a depth-first search traversal. It can have one of the following values:
- OptionalonlyOne: boolean
  The onlyOne parameter in the _dfs method is a boolean flag that determines whether the traversal should stop after processing a single node. If onlyOne is set to true, the traversal will return as soon as a single node is processed. If it is set to false @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} startNode - The startNodeparameter in the_dfsmethod is used to specify the starting node for the depth-first search traversal. It can be provided in different forms: @param {IterationType} iterationType - TheiterationTypeparameter in the_dfsmethod specifies whether the traversal should be done recursively or iteratively. It can have two possible values: @param [includeNull=false] - TheincludeNullparameter in the_dfsmethod determines whether null nodes should be included in the traversal process. IfincludeNullis set totrue, the method will consider null nodes as valid nodes to visit or process. If includeNullis set tofalse, @param shouldVisitLeft - The shouldVisitLeftparameter in the_dfsmethod is a function that determines whether the left child of a node should be visited during the Depth-First Search traversal. By default, it checks if the node is not null or undefined before visiting the left child. You can customize this behavior @param shouldVisitRight - TheshouldVisitRightparameter in the_dfsmethod is a function that determines whether to visit the right child node of the current node during a depth-first search traversal. The default implementation of this function checks if the node is not null or undefined before deciding to visit it. @param shouldVisitRoot - TheshouldVisitRootparameter in the_dfsmethod is a function that determines whether a given node should be visited during the depth-first search traversal. The function takes a node as an argument and returns a boolean value indicating whether the node should be visited. @param shouldProcessRoot - TheshouldProcessRootparameter in the_dfsmethod is a function that determines whether the root node should be processed during the Depth-First Search traversal. It takes a node (BinaryTreeNode<K, V> | null | undefined) as input and returns a boolean value. If the function @returns The_dfsmethod returns an array of the return type of the provided callback functionC`.
- OptionalstartNode:
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
- OptionaliterationType: IterationType
- OptionalincludeNull: boolean
- OptionalshouldVisitLeft: ((node: undefined | null | BinaryTreeNode<K, V>) => boolean)
  - - (node): boolean
    - Parameters
      node: undefined | null | BinaryTreeNode<K, V>
      Returns boolean
- OptionalshouldVisitRight: ((node: undefined | null | BinaryTreeNode<K, V>) => boolean)
  - - (node): boolean
    - Parameters
      node: undefined | null | BinaryTreeNode<K, V>
      Returns boolean
- OptionalshouldVisitRoot: ((node: undefined | null | BinaryTreeNode<K, V>) => boolean)
  - - (node): boolean
    - Parameters
      node: undefined | null | BinaryTreeNode<K, V>
      Returns boolean
- OptionalshouldProcessRoot: ((node: undefined | null | BinaryTreeNode<K, V>) => boolean)
  - - (node): boolean
    - Parameters
      node: undefined | null | BinaryTreeNode<K, V>
      Returns boolean
Returns ReturnType<C>[]
- Defined in binary-tree/binary-tree.ts:2020

`Protected`_displayAux

_displayAux(node, options): NodeDisplayLayout
Time Complexity: O(n) Space Complexity: O(n)

The function _displayAux in TypeScript is responsible for generating the display layout of nodes in a binary tree based on specified options.
Parameters
- node: undefined | null | BinaryTreeNode<K, V>
  The node parameter in the _displayAux function represents a node in a binary tree. It can be either a valid node containing a key or a special type of node like null, undefined, or a Red-Black tree NIL node. The function checks the type of the node and its
- options: BinaryTreePrintOptions
  The options parameter in the _displayAux function contains the following properties:
Returns NodeDisplayLayout
The _displayAux function returns a NodeDisplayLayout, which is an array containing information about how to display a node in a binary tree. The NodeDisplayLayout consists of four elements:
- Defined in binary-tree/binary-tree.ts:2247

`Protected`_ensurePredicate

_ensurePredicate(keyNodeEntryOrPredicate): NodePredicate<BinaryTreeNode<K, V>>
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<BinaryTreeNode<K, V>>
  The _ensurePredicate method in the provided code snippet is responsible for ensuring that the input parameter keyNodeEntryOrPredicate is transformed into a valid predicate function that can be used for filtering nodes in a binary tree.
Returns NodePredicate<BinaryTreeNode<K, V>>
A NodePredicate<BinaryTreeNode<K, V>> function is being returned.
- Defined in binary-tree/binary-tree.ts:2407

`Protected`_extractKey

_extractKey(keyNodeOrEntry): undefined | null | K
Time Complexity: O(1) Space Complexity: O(1)

The function _extractKey in TypeScript returns the key from a given input, which can be a node, entry, raw data, or null/undefined.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  The _extractKey method you provided is a TypeScript method that takes in a parameter keyNodeOrEntry of type K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined , where BTNRep is a generic type with keys K, V, and BinaryTreeNode<K, V>, and @returns The_extractKeymethod returns the key value extracted from thekeyNodeOrEntryparameter. The return value can be a key value of typeK, null, or undefined`, depending on the conditions checked in the method.
Returns undefined | null | K
- Defined in binary-tree/binary-tree.ts:2489

`Protected`_getIterator

_getIterator(node?): IterableIterator<[K, undefined | V], any, any>
Time Complexity: O(1) Space Complexity: O(1)

The function _getIterator returns an iterable iterator for a binary tree data structure, either using an iterative approach or a recursive approach based on the specified iteration type.
Parameters
- node: undefined | null | BinaryTreeNode<K, V> = ...
  The node parameter in the _getIterator method represents the current node being processed during iteration. It is initially set to the root node of the data structure (or the node passed as an argument), and then it is traversed through the data structure based on the iteration type specified (ITER @returns The _getIteratormethod returns an IterableIterator containing key-value pairs of nodes in a binary tree structure. The method uses an iterative approach to traverse the tree based on theiterationTypeproperty. If theiterationTypeis set to 'ITERATIVE', the method uses a stack to perform an in-order traversal of the tree. If theiterationType` is not 'ITERATIVE
Returns IterableIterator<[K, undefined | V], any, any>
Overrides IterableEntryBase._getIterator
- Defined in binary-tree/binary-tree.ts:2199

`Protected`_isPredicate

_isPredicate(p): p is NodePredicate<BinaryTreeNode<K, V>>
Time Complexity: O(1) Space Complexity: O(1)

The function _isPredicate checks if a given parameter is a function.
Parameters
- p: any
  The parameter p is a variable of type any, which means it can hold any type of value. In this context, the function _isPredicate is checking if p is a function that satisfies the type NodePredicate<BinaryTreeNode<K, V>>.
Returns p is NodePredicate<BinaryTreeNode<K, V>>
The function is checking if the input p is a function and returning a boolean value based on that check. If p is a function, it will return true, indicating that p is a predicate function for a binary tree node. If p is not a function, it will return false.
- Defined in binary-tree/binary-tree.ts:2472

`Protected`_keyValueNodeOrEntryToNodeAndValue

_keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value?): [undefined | null | BinaryTreeNode<K, V>, undefined | V]
Time Complexity: O(1) Space Complexity: O(1)

The function keyValueNodeEntryRawToNodeAndValue converts various input types into a node object or returns null.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  The keyValueNodeEntryRawToNodeAndValue function takes in a parameter keyNodeOrEntry, which can be of type K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined or R. This parameter represents either a key, a node, an entry
- Optionalvalue: V
  The value parameter in the keyValueNodeEntryRawToNodeAndValue function is an optional parameter of type V. It represents the value associated with the key in the node being created. If a value is provided, it will be used when creating the node. If
Returns [undefined | null | BinaryTreeNode<K, V>, undefined | V]
The keyValueNodeEntryRawToNodeAndValue function returns an optional node (BinaryTreeNode<K, V> | null | undefined) based on the input parameters provided. The function checks the type of the input parameter (keyNodeOrEntry) and processes it accordingly to return a node or null value.
- Defined in binary-tree/binary-tree.ts:2000

`Protected`_replaceNode

_replaceNode(oldNode, newNode): BinaryTreeNode<K, V>
Time Complexity: O(1) Space Complexity: O(1)

The _replaceNode function replaces an old node with a new node in a binary tree structure.
Parameters
- oldNode: BinaryTreeNode<K, V>
  The oldNode parameter represents the node that you want to replace in a tree data structure.
- newNode: BinaryTreeNode<K, V>
  The newNode parameter in the _replaceNode function represents the node that will replace the oldNode in a tree data structure. This function is responsible for updating the parent, left child, right child, and root (if necessary) references when replacing a node in the tree.
Returns BinaryTreeNode<K, V>
The method _replaceNode is returning the newNode that was passed as a parameter after replacing the oldNode with it in the binary tree structure.
- Defined in binary-tree/binary-tree.ts:2373

`Protected`_setRoot

_setRoot(v): void
Time Complexity: O(1) Space Complexity: O(1)

The function _setRoot sets the root node of a data structure while updating the parent reference of the previous root node.
Parameters
- v: undefined | null | BinaryTreeNode<K, V>
  The parameter v in the _setRoot method is of type BinaryTreeNode<K, V> | null | undefined, which means it can either be an optional BinaryTreeNode<K, V> type or null.
Returns void
- Defined in binary-tree/binary-tree.ts:2400

`Protected`_setValue

_setValue(key, value): false | Map<K, undefined | V>
Time Complexity: O(1) Space Complexity: O(1)

The function _setValue sets a value in a store based on a key, handling cases where the key or value is null or undefined.
Parameters
- key: undefined | null | K
  The key parameter can be of type K, null, or undefined.
- value: undefined | V
  The value parameter in the _setValue method can be of type V or undefined.
Returns false | Map<K, undefined | V>
The method _setValue returns false if either the key is null or undefined, or if the value is undefined. Otherwise, it returns the result of calling the set method on the _store object with the key and value arguments.
- Defined in binary-tree/binary-tree.ts:2516

`Protected`_swapProperties

_swapProperties(srcNode, destNode): undefined | BinaryTreeNode<K, V>
Time Complexity: O(1) Space Complexity: O(1)

The _swapProperties function swaps key and value properties between two nodes in a binary tree.
Parameters
- srcNode:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  The srcNode parameter in the _swapProperties method can be either a BTNRep object containing key and value properties, or it can be of type R.
- destNode:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  The destNode parameter in the _swapProperties method represents the node or entry where the properties will be swapped with the srcNode. It can be of type K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined or R. The method ensures that both srcNode @returns The _swapPropertiesmethod returns either thedestNodewith its key and value swapped with thesrcNode, or undefinedif eithersrcNodeordestNode` is falsy.
Returns undefined | BinaryTreeNode<K, V>
- Defined in binary-tree/binary-tree.ts:2335

[iterator]

[iterator](...args): IterableIterator<[K, undefined | V], any, any>
Time Complexity: O(n) Space Complexity: O(1)

The function is an implementation of the Symbol.iterator method that returns an iterable iterator.
Parameters
- Rest...args: any[]
  The args parameter in the code snippet represents a rest parameter. It allows the function to accept any number of arguments as an array. In this case, the args parameter is used to pass any additional arguments to the _getIterator method.
Returns IterableIterator<[K, undefined | V], any, any>
Inherited from IterableEntryBase.[iterator]
- Defined in base/iterable-entry-base.ts:15

add

add(keyNodeOrEntry, value?): boolean
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.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  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:
- Optionalvalue: V
  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 boolean
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.
Implementation of IBinaryTree.add
- Defined in binary-tree/binary-tree.ts:529

addMany

addMany(keysNodesEntriesOrRaws, values?): 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.
Parameters
- keysNodesEntriesOrRaws: Iterable<
      | undefined
      | null
      | K
      | R
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V], any, any>
  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.
- Optionalvalues: Iterable<undefined | V, any, any>
  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 boolean[]
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.
Implementation of IBinaryTree.addMany
- Defined in binary-tree/binary-tree.ts:608

bfs

bfs<C>(callback?, startNode?, iterationType?, includeNull?): ReturnType<C>[]
Type Parameters
- C extends NodeCallback<BinaryTreeNode<K, V>>
Parameters
- Optionalcallback: C
- OptionalstartNode:
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
- OptionaliterationType: IterationType
- OptionalincludeNull: false
Returns ReturnType<C>[]
- Defined in binary-tree/binary-tree.ts:1479
bfs<C>(callback?, startNode?, iterationType?, includeNull?): ReturnType<C>[]
Type Parameters
- C extends NodeCallback<null | BinaryTreeNode<K, V>>
Parameters
- Optionalcallback: C
- OptionalstartNode:
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
- OptionaliterationType: IterationType
- OptionalincludeNull: true
Returns ReturnType<C>[]
- Defined in binary-tree/binary-tree.ts:1486

clear

clear(): void
Time Complexity: O(1) Space Complexity: O(1)

The clear function removes nodes and values in map mode.

Returns void
Overrides IterableEntryBase.clear
- Defined in binary-tree/binary-tree.ts:980

clone

clone(): BinaryTree<K, V, R, MK, MV, MR>
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 BinaryTree<K, V, R, MK, MV, MR>
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
Overrides IterableEntryBase.clone
- Defined in binary-tree/binary-tree.ts:1835

createNode

createNode(key, value?): BinaryTreeNode<K, V>
Time Complexity: O(1) Space Complexity: O(1)

The function creates a new binary tree node with a specified key and optional value.
Parameters
- key: K
  The key parameter is the key of the node being created in the binary tree.
- Optionalvalue: V
  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 BinaryTreeNode<K, V>
A new BinaryTreeNode instance with the provided key and value is being returned, casted as BinaryTreeNode<K, V>.
Implementation of IBinaryTree.createNode
- Defined in binary-tree/binary-tree.ts:283

createTree

createTree(options?): BinaryTree<K, V, R, MK, MV, MR>
Time Complexity: O(1) Space Complexity: O(1)

The function creates a binary tree with the specified options.
Parameters
- Optionaloptions: BinaryTreeOptions<K, V, R>
  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 BinaryTree<K, V, R, MK, MV, MR>
A new instance of a binary tree with the specified options is being returned.
Implementation of IBinaryTree.createTree
- Defined in binary-tree/binary-tree.ts:298

delete

delete(keyNodeOrEntry): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[]
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.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  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 BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[]
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).
Implementation of IBinaryTree.delete
- Defined in binary-tree/binary-tree.ts:687

dfs

dfs<C>(callback?, pattern?, onlyOne?, startNode?, iterationType?): ReturnType<C>[]
Type Parameters
- C extends NodeCallback<BinaryTreeNode<K, V>>
Parameters
- Optionalcallback: C
- Optionalpattern: DFSOrderPattern
- OptionalonlyOne: boolean
- OptionalstartNode:
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
- OptionaliterationType: IterationType
Returns ReturnType<C>[]
- Defined in binary-tree/binary-tree.ts:1421
dfs<C>(callback?, pattern?, onlyOne?, startNode?, iterationType?, includeNull?): ReturnType<C>[]
Type Parameters
- C extends NodeCallback<null | BinaryTreeNode<K, V>>
Parameters
- Optionalcallback: C
- Optionalpattern: DFSOrderPattern
- OptionalonlyOne: boolean
- OptionalstartNode:
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
- OptionaliterationType: IterationType
- OptionalincludeNull: boolean
Returns ReturnType<C>[]
- Defined in binary-tree/binary-tree.ts:1429

ensureNode

ensureNode(keyNodeOrEntry, iterationType?): undefined | null | BinaryTreeNode<K, V>
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.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  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
- 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 undefined | null | BinaryTreeNode<K, V>
The ensureNode function returns either a node, null, or undefined based on the conditions specified in the code snippet.
- Defined in binary-tree/binary-tree.ts:322

entries

entries(): IterableIterator<[K, undefined | V], any, any>
Time Complexity: O(n) Space Complexity: O(n)

The function returns an iterator that yields key-value pairs from the object, where the value can be undefined.

Returns IterableIterator<[K, undefined | V], any, any>
Inherited from IterableEntryBase.entries
- Defined in base/iterable-entry-base.ts:26

every

every(predicate, thisArg?): boolean
Time Complexity: O(n) Space Complexity: O(1)

The every function checks if every element in a collection satisfies a given condition.
Parameters
- predicate: EntryCallback<K, undefined | V, boolean>
  The predicate parameter is a callback function that takes three arguments: value, key, and index. It should return a boolean value indicating whether the condition is met for the current element in the iteration.
- OptionalthisArg: any
  The thisArg parameter is an optional argument that specifies the value to be used as this when executing the predicate function. If thisArg is provided, it will be passed as the first argument to the predicate function. If thisArg is not provided
Returns boolean
The every method is returning a boolean value. It returns true if every element in the collection satisfies the provided predicate function, and false otherwise.
Inherited from IterableEntryBase.every
- Defined in base/iterable-entry-base.ts:70

filter

filter(predicate, thisArg?): 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.
Parameters
- predicate: EntryCallback<K, undefined | V, boolean>
  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] - ThethisArgparameter in thefiltermethod allows you to specify the value ofthisthat should be used when executing thepredicatefunction. This is useful when thepredicatefunction relies on the context of a specific object or value. By providing athisArg
- OptionalthisArg: any
Returns BinaryTree<K, V, R, MK, MV, MR>
The filter method is returning a new tree that contains entries that pass the provided predicate function.
Overrides IterableEntryBase.filter
- Defined in binary-tree/binary-tree.ts:1857

find

find(callbackfn, thisArg?): undefined | [K, undefined | V]
Time Complexity: O(n) Space Complexity: O(1)

The find function iterates over the entries of a collection and returns the first value for which the callback function returns true.
Parameters
- callbackfn: EntryCallback<K, undefined | V, boolean>
  The callback function that will be called for each entry in the collection. It takes three arguments: the value of the entry, the key of the entry, and the index of the entry in the collection. It should return a boolean value indicating whether the current entry matches the desired condition.
- OptionalthisArg: any
  The thisArg parameter is an optional argument that specifies the value to be used as this when executing the callbackfn function. If thisArg is provided, it will be passed as the this value to the callbackfn function. If thisArg @returns The method findreturns the value of the first element in the iterable that satisfies the provided callback function. If no element satisfies the callback function,undefined` is returned.
Returns undefined | [K, undefined | V]
Inherited from IterableEntryBase.find
- Defined in base/iterable-entry-base.ts:143

forEach

forEach(callbackfn, thisArg?): void
Time Complexity: O(n) Space Complexity: O(1)

The forEach function iterates over each key-value pair in a collection and executes a callback function for each pair.
Parameters
- callbackfn: EntryCallback<K, undefined | V, void>
  The callback function that will be called for each element in the collection. It takes four parameters: the value of the current element, the key of the current element, the index of the current element, and the collection itself.
- OptionalthisArg: any
  The thisArg parameter is an optional argument that allows you to specify the value of this within the callback function. If thisArg is provided, it will be used as the this value when calling the callback function. If thisArg is not provided, `
Returns void
Inherited from IterableEntryBase.forEach
- Defined in base/iterable-entry-base.ts:118

get

get(keyNodeEntryOrPredicate, startNode?, iterationType?): undefined | V
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.
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  The keyNodeEntryOrPredicate parameter in the get method can accept one of the following types:
- startNode:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V] = ...
  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).
- 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 undefined | V
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.
Overrides IterableEntryBase.get
- Defined in binary-tree/binary-tree.ts:914

getDepth

getDepth(dist, startNode?): number
Time Complexity: O(n) Space Complexity: O(log n)

The getDepth function calculates the depth between two nodes in a binary tree.
Parameters
- dist:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  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.
- startNode:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V] = ...
  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 number
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.
- Defined in binary-tree/binary-tree.ts:1097

getHeight

getHeight(startNode?, iterationType?): 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.
Parameters
- startNode:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V] = ...
  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.
- 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 number
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.
- Defined in binary-tree/binary-tree.ts:1131

getLeftMost

getLeftMost<C>(callback?, startNode?, iterationType?): 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.
Type Parameters
- C extends NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>
Parameters
- callback: C = ...
  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.
- startNode:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V] = ...
  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
- 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 ReturnType<C>
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
- Defined in binary-tree/binary-tree.ts:1288

getMinHeight

getMinHeight(startNode?, 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.
Parameters
- startNode:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V] = ...
  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
- 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 number
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.
- Defined in binary-tree/binary-tree.ts:1182

getNode

getNode(keyNodeEntryOrPredicate, startNode?, iterationType?): undefined | null | 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.
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<null | BinaryTreeNode<K, V>>
  The keyNodeEntryOrPredicate parameter in the getNode function can accept a key, node, entry, raw data, or a predicate function.
- startNode:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V] = ...
  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.
- 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 undefined | null | BinaryTreeNode<K, V>
The getNode function is returning the first node that matches the specified criteria, or null if no matching node is found.
- Defined in binary-tree/binary-tree.ts:878

getNodes

getNodes(keyNodeEntryOrPredicate, onlyOne?, startNode?, iterationType?): BinaryTreeNode<K, V>[]
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<BinaryTreeNode<K, V>>
  The getNodes function you provided takes several parameters:
- OptionalonlyOne: boolean
  The onlyOne parameter in the getNodes function is a boolean flag that determines whether to return only the first node that matches the criteria specified by the keyNodeEntryOrPredicate parameter. If onlyOne is set to true, the function will
- OptionalstartNode:
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  The startNode parameter in the getNodes function is used to specify the starting point for traversing the binary tree. It represents the root node of the binary tree or the node from which the traversal should begin. If not provided, the default value is set to this._root @param {IterationType} iterationType - The iterationTypeparameter in thegetNodesfunction determines the type of iteration to be performed when traversing the nodes of a binary tree. It can have two possible values: @returns ThegetNodes` function returns an array of nodes that satisfy the provided condition based on the input parameters and the iteration type specified.
- OptionaliterationType: IterationType
Returns BinaryTreeNode<K, V>[]
- Defined in binary-tree/binary-tree.ts:809

getPathToRoot

getPathToRoot<C>(beginNode, callback?, isReverse?): ReturnType<C>[]
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.
Type Parameters
- C extends NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>
Parameters
- beginNode:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
- callback: C = ...
  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 beginNodeparameter in thegetPathToRootfunction can be either a key, a node, an entry, or any other value of typeR. @param [isReverse=true] - The isReverseparameter in thegetPathToRootfunction determines whether the resulting path from the givenbeginNodeto the root should be in reverse order or not. IfisReverseis set totrue, the path will be reversed before being returned. If is
- OptionalisReverse: boolean = false
Returns ReturnType<C>[]
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.
- Defined in binary-tree/binary-tree.ts:1248

getPredecessor

getPredecessor(node): BinaryTreeNode<K, V>
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.
Parameters
- node: BinaryTreeNode<K, V>
  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 BinaryTreeNode<K, V>
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.
- Defined in binary-tree/binary-tree.ts:1378

getRightMost

getRightMost<C>(callback?, startNode?, 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.
Type Parameters
- C extends NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>
Parameters
- callback: C = ...
  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
- startNode:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V] = ...
  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
- 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 ReturnType<C>
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).
- Defined in binary-tree/binary-tree.ts:1338

getSuccessor

getSuccessor(x?): undefined | null | 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.
Parameters
- Optionalx: null | K | BinaryTreeNode<K, V>
  The getSuccessor function takes a parameter x, which can be of type K, BinaryTreeNode<K, V>, or null.
Returns undefined | null | BinaryTreeNode<K, V>
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
- Defined in binary-tree/binary-tree.ts:1405

has

has(keyNodeEntryOrPredicate?, startNode?, iterationType?): boolean
Time Complexity: O(n) Space Complexity: O(1)

The function checks if a given key exists in a collection.
Parameters
- OptionalkeyNodeEntryOrPredicate:
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<BinaryTreeNode<K, V>>
- OptionalstartNode:
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
- OptionaliterationType: IterationType
Returns boolean
a boolean value. It returns true if the key is found in the collection, and false otherwise.
Overrides IterableEntryBase.has
- Defined in binary-tree/binary-tree.ts:927

hasValue

hasValue(value): boolean
Time Complexity: O(n) Space Complexity: O(1)

The function checks if a given value exists in a collection.
Parameters
- value: undefined | V
  The parameter "value" is the value that we want to check if it exists in the collection.
Returns boolean
a boolean value, either true or false.
Inherited from IterableEntryBase.hasValue
- Defined in base/iterable-entry-base.ts:179

isBST

isBST(startNode?, iterationType?): 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.
Parameters
- startNode:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V] = ...
  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
- 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 boolean
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
- Defined in binary-tree/binary-tree.ts:1037

isEmpty

isEmpty(): boolean
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 boolean
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.
Overrides IterableEntryBase.isEmpty
- Defined in binary-tree/binary-tree.ts:994

isEntry

isEntry(keyNodeOrEntry): keyNodeOrEntry is BTNEntry<K, V>
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.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  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 isEntryfunction is checking if thekeyNodeOrEntryparameter is an array with a length of 2. If it is, then it returnstrue, indicating that the parameter is of type BTNEntry<K, V>. If the condition is not met, it returns false`.
Returns keyNodeOrEntry is BTNEntry<K, V>
- Defined in binary-tree/binary-tree.ts:490

isLeaf

isLeaf(keyNodeOrEntry): boolean
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.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  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 boolean
The function isLeaf returns a boolean value indicating whether the input keyNodeOrEntry is a leaf node in a binary tree.
- Defined in binary-tree/binary-tree.ts:470

isNIL

isNIL(keyNodeOrEntry): boolean
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.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  BTNRep<K, V, BinaryTreeNode<K, V>>
Returns boolean
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.
- Defined in binary-tree/binary-tree.ts:426

isNode

isNode(keyNodeOrEntry): keyNodeOrEntry is BinaryTreeNode<K, V>
Time Complexity: O(1) Space Complexity: O(1)

The function isNode checks if the input is an instance of BinaryTreeNode.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  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 keyNodeOrEntry is BinaryTreeNode<K, V>
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.
- Defined in binary-tree/binary-tree.ts:356

isPerfectlyBalanced

isPerfectlyBalanced(startNode?): 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.
Parameters
- startNode:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V] = ...
  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 boolean
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
- Defined in binary-tree/binary-tree.ts:1013

isRange

isRange(keyNodeEntryOrPredicate): keyNodeEntryOrPredicate is Range<K>
Time Complexity: O(1) Space Complexity: O(1)

The function isRange checks if the input parameter is an instance of the Range class.
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<BinaryTreeNode<K, V>>
      | Range<K>
  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 isRangefunction is checking if thekeyNodeEntryOrPredicateparameter is an instance of theRangeclass. If it is an instance ofRange, the function will return true, indicating that the parameter is a Range. If it is not an instance of Range, the function will return false`.
Returns keyNodeEntryOrPredicate is Range<K>
- Defined in binary-tree/binary-tree.ts:444

isRaw

isRaw(keyNodeEntryOrRaw): keyNodeEntryOrRaw is R
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.
Parameters
- keyNodeEntryOrRaw:
      | undefined
      | null
      | K
      | R
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
Returns keyNodeEntryOrRaw is R
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.
- Defined in binary-tree/binary-tree.ts:372

isRealNode

isRealNode(keyNodeOrEntry): keyNodeOrEntry is BinaryTreeNode<K, V>
Time Complexity: O(1) Space Complexity: O(1)

The function isRealNode checks if a given input is a valid node in a binary tree.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  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 keyNodeOrEntry is BinaryTreeNode<K, V>
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
- Defined in binary-tree/binary-tree.ts:391

isRealNodeOrNull

isRealNodeOrNull(keyNodeOrEntry): keyNodeOrEntry is null | BinaryTreeNode<K, V>
Time Complexity: O(1) Space Complexity: O(1)

The function checks if a given input is a valid node or null.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  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 keyNodeOrEntry is null | BinaryTreeNode<K, V>
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.
- Defined in binary-tree/binary-tree.ts:410

isValidKey

isValidKey(key): key is K
Time Complexity O(1) Space Complexity O(1)

The function isValidKey checks if a given key is comparable.
Parameters
- key: any
  The key parameter is of type any, which means it can be any data type in TypeScript.
Returns key is K
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.
- Defined in binary-tree/binary-tree.ts:507

keys

keys(): IterableIterator<K, any, any>
Time Complexity: O(n) Space Complexity: O(n)

The function returns an iterator that yields the keys of a data structure.

Returns IterableIterator<K, any, any>
Inherited from IterableEntryBase.keys
- Defined in base/iterable-entry-base.ts:38

leaves

leaves<C>(callback?, startNode?, iterationType?): 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.
Type Parameters
- C extends NodeCallback<null | BinaryTreeNode<K, V>>
Parameters
- callback: C = ...
  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.
- startNode:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V] = ...
  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
- 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 ReturnType<C>[]
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.
- Defined in binary-tree/binary-tree.ts:1590

listLevels

listLevels<C>(callback?, startNode?, iterationType?, includeNull?): ReturnType<C>[][]
Type Parameters
- C extends NodeCallback<BinaryTreeNode<K, V>>
Parameters
- Optionalcallback: C
- OptionalstartNode:
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
- OptionaliterationType: IterationType
- OptionalincludeNull: false
Returns ReturnType<C>[][]
- Defined in binary-tree/binary-tree.ts:1627
listLevels<C>(callback?, startNode?, iterationType?, includeNull?): ReturnType<C>[][]
Type Parameters
- C extends NodeCallback<null | BinaryTreeNode<K, V>>
Parameters
- Optionalcallback: C
- OptionalstartNode:
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
- OptionaliterationType: IterationType
- OptionalincludeNull: true
Returns ReturnType<C>[][]
- Defined in binary-tree/binary-tree.ts:1634

map

map(callback, options?, thisArg?): BinaryTree<MK, MV, MR, any, any, object>
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.
Parameters
- callback: EntryCallback<K, undefined | V, [MK, MV]>
  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.
- Optionaloptions: BinaryTreeOptions<MK, MV, MR>
  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
- OptionalthisArg: any
  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 BinaryTree<MK, MV, MR, any, any, object>
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.
Overrides IterableEntryBase.map
- Defined in binary-tree/binary-tree.ts:1887

merge

merge(anotherTree): void
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.
Parameters
- anotherTree: BinaryTree<K, V, R, MK, MV, MR>
  BinaryTree<K, V, R, MK, MV, MR>
Returns void
- Defined in binary-tree/binary-tree.ts:646

morris

morris<C>(callback?, pattern?, startNode?): ReturnType<C>[]
Type Parameters
- C extends NodeCallback<BinaryTreeNode<K, V>>
Parameters
- Optionalcallback: C
  The callback parameter in the morris function is a function that will be called on each node in the binary tree during the traversal. It is of type C, which extends the NodeCallback<BinaryTreeNode<K, V> | null> type. The default value for callback is this._DEFAULT @param {DFSOrderPattern} [pattern=IN] - The patternparameter in themorrisfunction specifies the type of Depth-First Search (DFS) order pattern to traverse the binary tree. The possible values for thepatternparameter are: @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined } startNode - ThestartNodeparameter in themorrisfunction is the starting point for the Morris traversal algorithm. It represents the root node of the binary tree or the node from which the traversal should begin. It can be provided as either a key, a node, an entry, or a reference @returns Themorris` function is returning an array of values that are the result of applying the provided callback function to each node in the binary tree in the specified order pattern (IN, PRE, or POST).
- Optionalpattern: DFSOrderPattern
- OptionalstartNode:
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
Returns ReturnType<C>[]
- Defined in binary-tree/binary-tree.ts:1712

print

print(options?, startNode?): void
Time Complexity: O(n) Space Complexity: O(n)

The function print in TypeScript overrides the default print behavior to log a visual representation of the binary tree to the console.
Parameters
- Optionaloptions: BinaryTreePrintOptions
  The options parameter is used to specify the printing options for the binary tree. It is an optional parameter that allows you to customize how the binary tree is printed, such as choosing between different traversal orders or formatting options.
- startNode:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V] = ...
  The startNode parameter in the override print method is used to specify the starting point for printing the binary tree. It can be either a key, a node, an entry, or the root of the tree. If no specific starting point is provided, the default value is set to
Returns void
Overrides IterableEntryBase.print
- Defined in binary-tree/binary-tree.ts:1959

reduce

reduce<U>(callbackfn, initialValue): U
Time Complexity: O(n) Space Complexity: O(1)

The reduce function iterates over key-value pairs and applies a callback function to each pair, accumulating a single value.
Type Parameters
- U
Parameters
- callbackfn: ReduceEntryCallback<K, undefined | V, U>
  The callback function that will be called for each element in the collection. It takes four arguments: the current accumulator value, the current value of the element, the key of the element, and the index of the element in the collection. It should return the updated accumulator value.
- initialValue: U
  The initialValue parameter is the initial value of the accumulator. It is the value that will be used as the first argument to the callbackfn function when reducing the elements of the collection.
Returns U
The reduce method is returning the final value of the accumulator after iterating over all the elements in the collection.
Inherited from IterableEntryBase.reduce
- Defined in base/iterable-entry-base.ts:220

refill

refill(keysNodesEntriesOrRaws, values?): 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.
Parameters
- keysNodesEntriesOrRaws: Iterable<
      | undefined
      | null
      | K
      | R
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V], any, any>
  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.
- Optionalvalues: Iterable<undefined | V, any, any>
  The values parameter in the refill method is an optional parameter that accepts an iterable of values of type V or undefined.
Returns void
- Defined in binary-tree/binary-tree.ts:662

search

search<C>(keyNodeEntryOrPredicate, onlyOne?, callback?, startNode?, iterationType?): ReturnType<C>[]
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.
Type Parameters
- C extends NodeCallback<null | BinaryTreeNode<K, V>>
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<null | BinaryTreeNode<K, V>>
  The keyNodeEntryOrPredicate parameter in the search function can accept three types of values:
- OptionalonlyOne: boolean = 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
- callback: C = ...
  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
- startNode:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V] = ...
  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
- 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 ReturnType<C>[]
The search function returns an array of values that match the provided criteria based on the search algorithm implemented within the function.
- Defined in binary-tree/binary-tree.ts:758

some

some(predicate, thisArg?): boolean
Time Complexity: O(n) Space Complexity: O(1)

The "some" function iterates over a collection and returns true if at least one element satisfies a given predicate.
Parameters
- predicate: EntryCallback<K, undefined | V, boolean>
  The predicate parameter is a callback function that takes three arguments: value, key, and index. It should return a boolean value indicating whether the condition is met for the current element in the iteration.
- OptionalthisArg: any
  The thisArg parameter is an optional argument that specifies the value to be used as the this value when executing the predicate function. If thisArg is provided, it will be passed as the first argument to the predicate function. If thisArg is
Returns boolean
a boolean value. It returns true if the predicate function returns true for any pair in the collection, and false otherwise.
Inherited from IterableEntryBase.some
- Defined in base/iterable-entry-base.ts:95

toVisual

toVisual(startNode?, options?): string
Time Complexity: O(n) Space Complexity: O(n)

The function toVisual in TypeScript overrides the visual representation of a binary tree with customizable options for displaying undefined, null, and sentinel nodes.
Parameters
- startNode:
      | undefined
      | null
      | K
      | BinaryTreeNode<K, V>
      | [undefined | null | K, undefined | V] = ...
  The startNode parameter in the toVisual method is used to specify the starting point for visualizing the binary tree structure. It can be a node, key, entry, or the root of the tree. If no specific starting point is provided, the default is set to the root
- Optionaloptions: BinaryTreePrintOptions
  The options parameter in the toVisual method is an object that contains the following properties:
Returns string
The override toVisual method returns a string that represents the visual display of the binary tree based on the provided options for showing undefined, null, and Red-Black NIL nodes. The method constructs the visual representation by calling the _displayAux method and appending the lines to the output string. The final output string contains the visual representation of the binary tree with the specified options.
Overrides IterableEntryBase.toVisual
- Defined in binary-tree/binary-tree.ts:1918

values

values(): IterableIterator<undefined | V, any, any>
Time Complexity: O(n) Space Complexity: O(n)

The function returns an iterator that yields the values of a collection.

Returns IterableIterator<undefined | V, any, any>
Inherited from IterableEntryBase.values
- Defined in base/iterable-entry-base.ts:50

Class BinaryTree<K, V, R, MK, MV, MR>

Example

Example

Type Parameters

Hierarchy (view full)

Implements

Index

Constructors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns BinaryTree<K, V, R, MK, MV, MR>

Methods

Protected_clearNodes

Returns void

Protected_clearValues

Returns void

Protected_dfs

Type Parameters

Parameters

Parameters

Returns boolean

Parameters

Returns boolean

Parameters

Returns boolean

Parameters

Returns boolean

Returns ReturnType<C>[]

Protected_displayAux

Parameters

Returns NodeDisplayLayout

Protected_ensurePredicate

Parameters

Returns NodePredicate<BinaryTreeNode<K, V>>

Protected_extractKey

Parameters

Returns undefined | null | K

Protected_getIterator

Parameters

Returns IterableIterator<[K, undefined | V], any, any>

Protected_isPredicate

Parameters

Returns p is NodePredicate<BinaryTreeNode<K, V>>

Protected_keyValueNodeOrEntryToNodeAndValue

Parameters

Returns [undefined | null | BinaryTreeNode<K, V>, undefined | V]

Protected_replaceNode

Parameters

Returns BinaryTreeNode<K, V>

Protected_setRoot

Parameters

Returns void

Protected_setValue

Parameters

Returns false | Map<K, undefined | V>

Protected_swapProperties

Parameters

Returns undefined | BinaryTreeNode<K, V>

[iterator]

Parameters

Returns IterableIterator<[K, undefined | V], any, any>

add

Parameters

Returns boolean

addMany

Parameters

Returns boolean[]

bfs

Type Parameters

Parameters

Returns ReturnType<C>[]

Type Parameters

Parameters

Returns ReturnType<C>[]

clear

Returns void

clone

`Protected`_clearNodes

`Protected`_clearValues

`Protected`_dfs

`Protected`_displayAux

`Protected`_ensurePredicate

`Protected`_extractKey

`Protected`_getIterator

`Protected`_isPredicate

`Protected`_keyValueNodeOrEntryToNodeAndValue

`Protected`_replaceNode

`Protected`_setRoot

`Protected`_setValue

`Protected`_swapProperties