data-structure-typed 1.47.5 → 1.47.6

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

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, BTNKey } from '../../types';
-import { BinaryTreeNested, BinaryTreePrintOptions, BiTreeDeleteResult, DFSOrderPattern, FamilyPosition, IterationType, NodeDisplayLayout } from '../../types';
+import { BinaryTreeNested, BinaryTreePrintOptions, BiTreeDeleteResult, DFSOrderPattern, FamilyPosition, IterableEntriesOrKeys, IterationType, NodeDisplayLayout } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 /**
  * Represents a node in a binary tree.
@@ -63,12 +63,12 @@ export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = Bi
  * @template N - The type of the binary tree's nodes.
  */
 export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>, TREE extends BinaryTree<V, N, TREE> = BinaryTree<V, N, BinaryTreeNested<V, N>>> implements IBinaryTree<V, N, TREE> {
-    options: BinaryTreeOptions;
+    iterationType: IterationType;
     /**
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
-    constructor(options?: BinaryTreeOptions);
+    constructor(elements?: IterableEntriesOrKeys<V>, options?: Partial<BinaryTreeOptions>);
     protected _root?: N | null;
     /**
      * Get the root node of the binary tree.
@@ -86,12 +86,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns {N} - The newly created BinaryTreeNode.
      */
     createNode(key: BTNKey, value?: V): N;
-    createTree(options?: BinaryTreeOptions): TREE;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     * Comments: The time complexity for adding a node depends on the depth of the tree. In the best case (when the tree is empty), it's O(1). In the worst case (when the tree is a degenerate tree), it's O(n). The space complexity is constant.
-     */
+    createTree(options?: Partial<BinaryTreeOptions>): TREE;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -107,8 +102,9 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      */
     add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | null | undefined;
     /**
-     * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
+     * Comments: The time complexity for adding a node depends on the depth of the tree. In the best case (when the tree is empty), it's O(1). In the worst case (when the tree is a degenerate tree), it's O(n). The space complexity is constant.
      */
     /**
      * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
@@ -142,6 +138,10 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns The method is returning a boolean value.
      */
     refill(keysOrNodes: (BTNKey | N | null | undefined)[], values?: (V | undefined)[]): boolean;
+    /**
+     * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
+     * Space Complexity: O(1)
+     */
     delete<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C): BiTreeDeleteResult<N>[];
     delete<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C): BiTreeDeleteResult<N>[];
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C): BiTreeDeleteResult<N>[];
@@ -165,8 +165,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     getDepth(distNode: BTNKey | N | null | undefined, beginRoot?: BTNKey | N | null | undefined): number;
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     * Best Case - O(log n) (when using recursive iterationType), Worst Case - O(n) (when using iterative iterationType)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
@@ -182,7 +181,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * values:
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType | undefined): number;
+    getHeight(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -201,10 +200,11 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * to calculate the minimum height of a binary tree. It can have two possible values:
      * @returns The function `getMinHeight` returns the minimum height of a binary tree.
      */
-    getMinHeight(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType | undefined): number;
+    getMinHeight(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
+     * Best Case - O(log n) (when using recursive iterationType), Worst Case - O(n) (when using iterative iterationType)
      */
     /**
      * Time Complexity: O(n)
@@ -218,12 +218,24 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns a boolean value.
      */
     isPerfectlyBalanced(beginRoot?: BTNKey | N | null | undefined): boolean;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
     getNodes<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, onlyOne?: boolean, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): N[];
     getNodes<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): N[];
     getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): N[];
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n).
+     */
     has<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): boolean;
     has<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): boolean;
     has<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): boolean;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n).
+     */
     getNode<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): N | null | undefined;
     getNode<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): N | null | undefined;
     getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): N | null | undefined;
@@ -246,6 +258,10 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
     getNodeByKey(key: BTNKey, iterationType?: IterationType): N | undefined;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
     /**
      * The function `ensureNotKey` returns the node corresponding to the given key if it is a valid node
      * key, otherwise it returns the key itself.
@@ -261,6 +277,10 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     get<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): V | undefined;
     get<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): V | undefined;
     get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): V | undefined;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
     /**
      * Clear the binary tree, removing all nodes.
      */
@@ -270,10 +290,6 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns {boolean} - True if the binary tree is empty, false otherwise.
      */
     isEmpty(): boolean;
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
@@ -291,7 +307,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     getPathToRoot(beginRoot: BTNKey | N | null | undefined, isReverse?: boolean): N[];
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      */
     /**
      * Time Complexity: O(log n)
@@ -307,7 +323,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns The function `getLeftMost` returns the leftmost node (`N`) in the binary tree. If there
      * is no leftmost node, it returns `null` or `undefined` depending on the input.
      */
-    getLeftMost(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType | undefined): N | null | undefined;
+    getLeftMost(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): N | null | undefined;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -327,9 +343,9 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns The function `getRightMost` returns the rightmost node (`N`) in a binary tree. If there
      * is no rightmost node, it returns `null` or `undefined`, depending on the input.
      */
-    getRightMost(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType | undefined): N | null | undefined;
+    getRightMost(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): N | null | undefined;
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
@@ -344,7 +360,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * possible values:
      * @returns a boolean value.
      */
-    isSubtreeBST(beginRoot: BTNKey | N | null | undefined, iterationType?: IterationType | undefined): boolean;
+    isSubtreeBST(beginRoot: BTNKey | N | null | undefined, iterationType?: IterationType): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -360,10 +376,18 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * expected to be
      * @returns a boolean value.
      */
-    isBST(iterationType?: IterationType | undefined): boolean;
+    isBST(iterationType?: IterationType): boolean;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
     subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
     subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
     subTreeTraverse<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(log n)
+     */
     /**
      * The function checks if a given node is a real node by verifying if it is an instance of
      * BinaryTreeNode and its key is not NaN.
@@ -393,12 +417,24 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
     dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
     dfs<C extends BTNCallback<N | null | undefined>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
     bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
     bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
     bfs<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
     listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
     listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[][];
     listLevels<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
     getPredecessor(node: N): N;
     /**
      * The function `getSuccessor` returns the next node in a binary tree given a current node.
@@ -407,10 +443,6 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * after the given node in the inorder traversal of the binary tree.
      */
     getSuccessor(x?: BTNKey | N | null): N | null | undefined;
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(1)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(1)
@@ -430,6 +462,10 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * by the return type of the `callback` function.
      */
     morris<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKey | N | null | undefined): ReturnType<C>[];
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(1)
+     */
     /**
      * The `forEach` function iterates over each entry in a tree and calls a callback function with the
      * entry and the tree as arguments.
@@ -484,6 +520,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @param {BinaryTreePrintOptions} [options={ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false}] - Options object that controls printing behavior. You can specify whether to display undefined, null, or sentinel nodes.
      */
     print(beginRoot?: BTNKey | N | null | undefined, options?: BinaryTreePrintOptions): void;
+    init(elements: IterableEntriesOrKeys<V>): void;
     protected _displayAux(node: N | null | undefined, options: BinaryTreePrintOptions): NodeDisplayLayout;
     protected _defaultOneParamCallback: (node: N) => number;
     /**

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

@@ -92,19 +92,21 @@ export class BinaryTreeNode {
  * @template N - The type of the binary tree's nodes.
  */
 export class BinaryTree {
-    options;
+    iterationType = IterationType.ITERATIVE;
     /**
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
-    constructor(options) {
+    constructor(elements, options) {
         if (options) {
-            this.options = { iterationType: IterationType.ITERATIVE, ...options };
-        }
-        else {
-            this.options = { iterationType: IterationType.ITERATIVE };
+            const { iterationType } = options;
+            if (iterationType) {
+                this.iterationType = iterationType;
+            }
         }
         this._size = 0;
+        if (elements)
+            this.init(elements);
     }
     _root;
     /**
@@ -130,13 +132,8 @@ export class BinaryTree {
         return new BinaryTreeNode(key, value);
     }
     createTree(options) {
-        return new BinaryTree({ ...this.options, ...options });
+        return new BinaryTree([], { iterationType: this.iterationType, ...options });
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     * Comments: The time complexity for adding a node depends on the depth of the tree. In the best case (when the tree is empty), it's O(1). In the worst case (when the tree is a degenerate tree), it's O(n). The space complexity is constant.
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -197,8 +194,9 @@ export class BinaryTree {
         return inserted;
     }
     /**
-     * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
+     * Comments: The time complexity for adding a node depends on the depth of the tree. In the best case (when the tree is empty), it's O(1). In the worst case (when the tree is a degenerate tree), it's O(n). The space complexity is constant.
      */
     /**
      * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
@@ -247,10 +245,6 @@ export class BinaryTree {
         this.clear();
         return keysOrNodes.length === this.addMany(keysOrNodes, values).length;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -346,8 +340,7 @@ export class BinaryTree {
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     * Best Case - O(log n) (when using recursive iterationType), Worst Case - O(n) (when using iterative iterationType)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
@@ -363,7 +356,7 @@ export class BinaryTree {
      * values:
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot = this.root, iterationType = this.options.iterationType) {
+    getHeight(beginRoot = this.root, iterationType = this.iterationType) {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return -1;
@@ -409,7 +402,7 @@ export class BinaryTree {
      * to calculate the minimum height of a binary tree. It can have two possible values:
      * @returns The function `getMinHeight` returns the minimum height of a binary tree.
      */
-    getMinHeight(beginRoot = this.root, iterationType = this.options.iterationType) {
+    getMinHeight(beginRoot = this.root, iterationType = this.iterationType) {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return -1;
@@ -456,6 +449,7 @@ export class BinaryTree {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
+     * Best Case - O(log n) (when using recursive iterationType), Worst Case - O(n) (when using iterative iterationType)
      */
     /**
      * Time Complexity: O(n)
@@ -471,10 +465,6 @@ export class BinaryTree {
     isPerfectlyBalanced(beginRoot = this.root) {
         return this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot);
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n).
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n).
@@ -500,7 +490,7 @@ export class BinaryTree {
      * traverse the binary tree. It can have two possible values:
      * @returns an array of nodes of type `N`.
      */
-    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.options.iterationType) {
+    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
         if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         beginRoot = this.ensureNotKey(beginRoot);
@@ -538,10 +528,6 @@ export class BinaryTree {
         }
         return ans;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n).
-     */
     /**
      * Time Complexity: O(n)
      *
@@ -562,15 +548,11 @@ export class BinaryTree {
      * be performed in a pre-order, in-order, or post-order manner.
      * @returns a boolean value.
      */
-    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
+    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -592,7 +574,7 @@ export class BinaryTree {
      * nodes are visited during the search.
      * @returns a value of type `N | null | undefined`.
      */
-    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
+    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
@@ -644,6 +626,10 @@ export class BinaryTree {
             }
         }
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
     /**
      * The function `ensureNotKey` returns the node corresponding to the given key if it is a valid node
      * key, otherwise it returns the key itself.
@@ -658,10 +644,6 @@ export class BinaryTree {
     ensureNotKey(key, iterationType = IterationType.ITERATIVE) {
         return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -684,11 +666,15 @@ export class BinaryTree {
      * @returns The value of the node with the given identifier is being returned. If the node is not
      * found, `undefined` is returned.
      */
-    get(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
+    get(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNode(identifier, callback, beginRoot, iterationType)?.value ?? undefined;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
     /**
      * Clear the binary tree, removing all nodes.
      */
@@ -703,10 +689,6 @@ export class BinaryTree {
     isEmpty() {
         return this.size === 0;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
@@ -738,7 +720,7 @@ export class BinaryTree {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      */
     /**
      * Time Complexity: O(log n)
@@ -754,7 +736,7 @@ export class BinaryTree {
      * @returns The function `getLeftMost` returns the leftmost node (`N`) in the binary tree. If there
      * is no leftmost node, it returns `null` or `undefined` depending on the input.
      */
-    getLeftMost(beginRoot = this.root, iterationType = this.options.iterationType) {
+    getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return beginRoot;
@@ -795,7 +777,7 @@ export class BinaryTree {
      * @returns The function `getRightMost` returns the rightmost node (`N`) in a binary tree. If there
      * is no rightmost node, it returns `null` or `undefined`, depending on the input.
      */
-    getRightMost(beginRoot = this.root, iterationType = this.options.iterationType) {
+    getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
         // TODO support get right most by passing key in
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
@@ -819,7 +801,7 @@ export class BinaryTree {
         }
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
@@ -834,7 +816,7 @@ export class BinaryTree {
      * possible values:
      * @returns a boolean value.
      */
-    isSubtreeBST(beginRoot, iterationType = this.options.iterationType) {
+    isSubtreeBST(beginRoot, iterationType = this.iterationType) {
         // TODO there is a bug
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
@@ -881,15 +863,11 @@ export class BinaryTree {
      * expected to be
      * @returns a boolean value.
      */
-    isBST(iterationType = this.options.iterationType) {
+    isBST(iterationType = this.iterationType) {
         if (this.root === null)
             return true;
         return this.isSubtreeBST(this.root, iterationType);
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(log n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(log n)
@@ -912,7 +890,7 @@ export class BinaryTree {
      * the `callback` function on each node in the subtree. The type of the array elements is determined
      * by the return type of the `callback` function.
      */
-    subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
+    subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
         beginRoot = this.ensureNotKey(beginRoot);
         const ans = [];
         if (!beginRoot)
@@ -952,6 +930,10 @@ export class BinaryTree {
         }
         return ans;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(log n)
+     */
     /**
      * The function checks if a given node is a real node by verifying if it is an instance of
      * BinaryTreeNode and its key is not NaN.
@@ -986,10 +968,6 @@ export class BinaryTree {
     isNodeKey(potentialKey) {
         return typeof potentialKey === 'number';
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -1119,10 +1097,6 @@ export class BinaryTree {
         }
         return ans;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -1144,7 +1118,7 @@ export class BinaryTree {
      * @returns an array of values that are the result of invoking the callback function on each node in
      * the breadth-first traversal of a binary tree.
      */
-    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
+    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return [];
@@ -1196,10 +1170,6 @@ export class BinaryTree {
         }
         return ans;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -1221,7 +1191,7 @@ export class BinaryTree {
      * be excluded
      * @returns The function `listLevels` returns a two-dimensional array of type `ReturnType<C>[][]`.
      */
-    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
+    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
         beginRoot = this.ensureNotKey(beginRoot);
         const levelsNodes = [];
         if (!beginRoot)
@@ -1313,10 +1283,6 @@ export class BinaryTree {
         }
         return y;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(1)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(1)
@@ -1420,6 +1386,10 @@ export class BinaryTree {
         }
         return ans;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(1)
+     */
     /**
      * The `forEach` function iterates over each entry in a tree and calls a callback function with the
      * entry and the tree as arguments.
@@ -1448,14 +1418,6 @@ export class BinaryTree {
         }
         return newTree;
     }
-    // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
-    // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: this) => NV) {
-    //   const newTree = this.createTree();
-    //   for (const [key, value] of this) {
-    //     newTree.add(key, callback([key, value], this));
-    //   }
-    //   return newTree;
-    // }
     /**
      * The `map` function creates a new tree by applying a callback function to each entry in the current
      * tree.
@@ -1469,6 +1431,14 @@ export class BinaryTree {
         }
         return newTree;
     }
+    // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
+    // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: this) => NV) {
+    //   const newTree = this.createTree();
+    //   for (const [key, value] of this) {
+    //     newTree.add(key, callback([key, value], this));
+    //   }
+    //   return newTree;
+    // }
     /**
      * The `reduce` function iterates over the entries of a tree and applies a callback function to each
      * entry, accumulating a single value.
@@ -1500,7 +1470,7 @@ export class BinaryTree {
     *[Symbol.iterator](node = this.root) {
         if (!node)
             return;
-        if (this.options.iterationType === IterationType.ITERATIVE) {
+        if (this.iterationType === IterationType.ITERATIVE) {
             const stack = [];
             let current = node;
             while (current || stack.length > 0) {
@@ -1554,6 +1524,19 @@ export class BinaryTree {
         };
         display(beginRoot);
     }
+    init(elements) {
+        if (elements) {
+            for (const entryOrKey of elements) {
+                if (Array.isArray(entryOrKey)) {
+                    const [key, value] = entryOrKey;
+                    this.add(key, value);
+                }
+                else {
+                    this.add(entryOrKey);
+                }
+            }
+        }
+    }
     _displayAux(node, options) {
         const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
         const emptyDisplayLayout = [['─'], 1, 0, 0];