data-structure-typed 1.51.0 → 1.51.2

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

@@ -143,6 +143,14 @@ export class BinaryTree extends IterableEntryBase {
     get size() {
         return this._size;
     }
+    _NIL = new BinaryTreeNode(NaN);
+    /**
+     * The function returns the value of the _NIL property.
+     * @returns The method is returning the value of the `_NIL` property.
+     */
+    get NIL() {
+        return this._NIL;
+    }
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
      * @param {K} key - The key for the new node.
@@ -219,23 +227,31 @@ export class BinaryTree extends IterableEntryBase {
      * itself if it is not a valid node key.
      */
     ensureNode(keyOrNodeOrEntry, iterationType = 'ITERATIVE') {
-        let res;
         if (this.isRealNode(keyOrNodeOrEntry)) {
-            res = keyOrNodeOrEntry;
+            return keyOrNodeOrEntry;
         }
         else if (this.isEntry(keyOrNodeOrEntry)) {
             if (keyOrNodeOrEntry[0] === null)
-                res = null;
-            else if (keyOrNodeOrEntry[0] !== undefined)
-                res = this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
+                return null;
+            if (keyOrNodeOrEntry[0] === undefined)
+                return;
+            return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
         }
         else {
             if (keyOrNodeOrEntry === null)
-                res = null;
-            else if (keyOrNodeOrEntry !== undefined)
-                res = this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+                return null;
+            if (keyOrNodeOrEntry === undefined)
+                return;
+            return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
         }
-        return res;
+    }
+    /**
+     * The function checks if a given node is a real node or null.
+     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * @returns a boolean value.
+     */
+    isNodeOrNull(node) {
+        return this.isRealNode(node) || node === null;
     }
     /**
      * The function "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
@@ -245,15 +261,6 @@ export class BinaryTree extends IterableEntryBase {
     isNode(keyOrNodeOrEntry) {
         return keyOrNodeOrEntry instanceof BinaryTreeNode;
     }
-    /**
-     * The function checks if a given value is an entry in a binary tree node.
-     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
-     * two type parameters V and NODE, representing the value and node type respectively.
-     * @returns a boolean value.
-     */
-    isEntry(keyOrNodeOrEntry) {
-        return Array.isArray(keyOrNodeOrEntry) && keyOrNodeOrEntry.length === 2;
-    }
     /**
      * 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.
@@ -261,7 +268,9 @@ export class BinaryTree extends IterableEntryBase {
      * @returns a boolean value.
      */
     isRealNode(node) {
-        return node instanceof BinaryTreeNode && String(node.key) !== 'NaN';
+        if (!this.isNode(node))
+            return false;
+        return node !== this.NIL;
     }
     /**
      * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
@@ -269,15 +278,16 @@ export class BinaryTree extends IterableEntryBase {
      * @returns a boolean value.
      */
     isNIL(node) {
-        return node instanceof BinaryTreeNode && String(node.key) === 'NaN';
+        return node === this.NIL;
     }
     /**
-     * The function checks if a given node is a real node or null.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * The function checks if a given value is an entry in a binary tree node.
+     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
+     * two type parameters V and NODE, representing the value and node type respectively.
      * @returns a boolean value.
      */
-    isNodeOrNull(node) {
-        return this.isRealNode(node) || node === null;
+    isEntry(keyOrNodeOrEntry) {
+        return Array.isArray(keyOrNodeOrEntry) && keyOrNodeOrEntry.length === 2;
     }
     /**
      * Time Complexity O(n)
@@ -411,14 +421,14 @@ export class BinaryTree extends IterableEntryBase {
      * specific node based on its value or object.
      * @param {C} callback - The `callback` parameter is a function that is used to determine the
      * identifier of the node to be deleted. It is optional and has a default value of
-     * `this._defaultOneParamCallback`. The `callback` function should return the identifier of the node.
+     * `this._DEFAULT_CALLBACK`. The `callback` function should return the identifier of the node.
      * @returns an array of `BinaryTreeDeleteResult<NODE>`.
      */
-    delete(identifier, callback = this._defaultOneParamCallback) {
+    delete(identifier, callback = this._DEFAULT_CALLBACK) {
         const deletedResult = [];
         if (!this.root)
             return deletedResult;
-        if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
+        if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         const curr = this.getNode(identifier, callback);
         if (!curr)
@@ -477,7 +487,7 @@ export class BinaryTree extends IterableEntryBase {
      * specific value.
      * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
      * input and returns a value of type `C`. It is used to determine if a node matches the given
-     * identifier. If no callback is provided, the `_defaultOneParamCallback` function is used as the
+     * identifier. If no callback is provided, the `_DEFAULT_CALLBACK` function is used as the
      * default
      * @param [onlyOne=false] - A boolean value indicating whether to only return the first node that
      * matches the identifier. If set to true, the function will stop iterating once it finds a matching
@@ -490,39 +500,39 @@ export class BinaryTree extends IterableEntryBase {
      * traverse the binary tree. It can have two possible values:
      * @returns an array of nodes of type `NODE`.
      */
-    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
-        if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
+    getNodes(identifier, callback = this._DEFAULT_CALLBACK, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+        if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
         const ans = [];
         if (iterationType === 'RECURSIVE') {
-            const _traverse = (cur) => {
+            const dfs = (cur) => {
                 if (callback(cur) === identifier) {
                     ans.push(cur);
                     if (onlyOne)
                         return;
                 }
-                if (!cur.left && !cur.right)
+                if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
+                this.isRealNode(cur.left) && dfs(cur.left);
+                this.isRealNode(cur.right) && dfs(cur.right);
             };
-            _traverse(beginRoot);
+            dfs(beginRoot);
         }
         else {
-            const queue = new Queue([beginRoot]);
-            while (queue.size > 0) {
-                const cur = queue.shift();
-                if (cur) {
+            const stack = [beginRoot];
+            while (stack.length > 0) {
+                const cur = stack.pop();
+                if (this.isRealNode(cur)) {
                     if (callback(cur) === identifier) {
                         ans.push(cur);
                         if (onlyOne)
                             return ans;
                     }
-                    cur.left && queue.push(cur.left);
-                    cur.right && queue.push(cur.right);
+                    this.isRealNode(cur.left) && stack.push(cur.left);
+                    this.isRealNode(cur.right) && stack.push(cur.right);
                 }
             }
         }
@@ -553,9 +563,7 @@ export class BinaryTree extends IterableEntryBase {
      * nodes are visited during the search.
      * @returns a value of type `NODE | null | undefined`.
      */
-    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
-        if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
-            callback = (node => node);
+    getNode(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
         return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
     }
     /**
@@ -580,27 +588,27 @@ export class BinaryTree extends IterableEntryBase {
         if (!this.root)
             return undefined;
         if (iterationType === 'RECURSIVE') {
-            const _dfs = (cur) => {
+            const dfs = (cur) => {
                 if (cur.key === key)
                     return cur;
                 if (!cur.left && !cur.right)
                     return;
                 if (cur.left)
-                    return _dfs(cur.left);
+                    return dfs(cur.left);
                 if (cur.right)
-                    return _dfs(cur.right);
+                    return dfs(cur.right);
             };
-            return _dfs(this.root);
+            return dfs(this.root);
         }
         else {
-            const queue = new Queue([this.root]);
-            while (queue.size > 0) {
-                const cur = queue.shift();
+            const stack = [this.root];
+            while (stack.length > 0) {
+                const cur = stack.pop();
                 if (cur) {
                     if (cur.key === key)
                         return cur;
-                    cur.left && queue.push(cur.left);
-                    cur.right && queue.push(cur.right);
+                    cur.left && stack.push(cur.left);
+                    cur.right && stack.push(cur.right);
                 }
             }
         }
@@ -631,9 +639,7 @@ export class BinaryTree extends IterableEntryBase {
      * @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.iterationType) {
-        if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
-            callback = (node => node);
+    get(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
         return this.getNode(identifier, callback, beginRoot, iterationType)?.value ?? undefined;
     }
     /**
@@ -661,8 +667,8 @@ export class BinaryTree extends IterableEntryBase {
      * 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.iterationType) {
-        if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
+    has(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
+        if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
     }
@@ -966,21 +972,21 @@ export class BinaryTree extends IterableEntryBase {
         if (!this.isRealNode(beginRoot))
             return beginRoot;
         if (iterationType === 'RECURSIVE') {
-            const _traverse = (cur) => {
+            const dfs = (cur) => {
                 if (!this.isRealNode(cur.left))
                     return cur;
-                return _traverse(cur.left);
+                return dfs(cur.left);
             };
-            return _traverse(beginRoot);
+            return dfs(beginRoot);
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            const _traverse = trampoline((cur) => {
+            const dfs = trampoline((cur) => {
                 if (!this.isRealNode(cur.left))
                     return cur;
-                return _traverse.cont(cur.left);
+                return dfs.cont(cur.left);
             });
-            return _traverse(beginRoot);
+            return dfs(beginRoot);
         }
     }
     /**
@@ -1010,21 +1016,21 @@ export class BinaryTree extends IterableEntryBase {
         if (!beginRoot)
             return beginRoot;
         if (iterationType === 'RECURSIVE') {
-            const _traverse = (cur) => {
+            const dfs = (cur) => {
                 if (!this.isRealNode(cur.right))
                     return cur;
-                return _traverse(cur.right);
+                return dfs(cur.right);
             };
-            return _traverse(beginRoot);
+            return dfs(beginRoot);
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            const _traverse = trampoline((cur) => {
+            const dfs = trampoline((cur) => {
                 if (!this.isRealNode(cur.right))
                     return cur;
-                return _traverse.cont(cur.right);
+                return dfs.cont(cur.right);
             });
-            return _traverse(beginRoot);
+            return dfs(beginRoot);
         }
     }
     /**
@@ -1109,65 +1115,65 @@ export class BinaryTree extends IterableEntryBase {
      * `false`, null or undefined
      * @returns an array of values that are the return values of the callback function.
      */
-    dfs(callback = this._defaultOneParamCallback, pattern = 'IN', beginRoot = this.root, iterationType = 'ITERATIVE', includeNull = false) {
+    dfs(callback = this._DEFAULT_CALLBACK, pattern = 'IN', beginRoot = this.root, iterationType = 'ITERATIVE', includeNull = false) {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
         const ans = [];
         if (iterationType === 'RECURSIVE') {
-            const _traverse = (node) => {
+            const dfs = (node) => {
                 switch (pattern) {
                     case 'IN':
                         if (includeNull) {
                             if (this.isRealNode(node) && this.isNodeOrNull(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             this.isNodeOrNull(node) && ans.push(callback(node));
                             if (this.isRealNode(node) && this.isNodeOrNull(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                         }
                         else {
                             if (this.isRealNode(node) && this.isRealNode(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             this.isRealNode(node) && ans.push(callback(node));
                             if (this.isRealNode(node) && this.isRealNode(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                         }
                         break;
                     case 'PRE':
                         if (includeNull) {
                             this.isNodeOrNull(node) && ans.push(callback(node));
                             if (this.isRealNode(node) && this.isNodeOrNull(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             if (this.isRealNode(node) && this.isNodeOrNull(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                         }
                         else {
                             this.isRealNode(node) && ans.push(callback(node));
                             if (this.isRealNode(node) && this.isRealNode(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             if (this.isRealNode(node) && this.isRealNode(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                         }
                         break;
                     case 'POST':
                         if (includeNull) {
                             if (this.isRealNode(node) && this.isNodeOrNull(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             if (this.isRealNode(node) && this.isNodeOrNull(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                             this.isNodeOrNull(node) && ans.push(callback(node));
                         }
                         else {
                             if (this.isRealNode(node) && this.isRealNode(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             if (this.isRealNode(node) && this.isRealNode(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                             this.isRealNode(node) && ans.push(callback(node));
                         }
                         break;
                 }
             };
-            _traverse(beginRoot);
+            dfs(beginRoot);
         }
         else {
             // 0: visit, 1: print
@@ -1240,14 +1246,14 @@ export class BinaryTree extends IterableEntryBase {
      * @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.iterationType, includeNull = false) {
+    bfs(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
         const ans = [];
         if (iterationType === 'RECURSIVE') {
             const queue = new Queue([beginRoot]);
-            const traverse = (level) => {
+            const dfs = (level) => {
                 if (queue.size === 0)
                     return;
                 const current = queue.shift();
@@ -1264,9 +1270,9 @@ export class BinaryTree extends IterableEntryBase {
                     if (this.isRealNode(current.right))
                         queue.push(current.right);
                 }
-                traverse(level + 1);
+                dfs(level + 1);
             };
-            traverse(0);
+            dfs(0);
         }
         else {
             const queue = new Queue([beginRoot]);
@@ -1317,7 +1323,7 @@ export class BinaryTree extends IterableEntryBase {
      * be excluded
      * @returns The function `listLevels` returns a two-dimensional array of type `ReturnType<C>[][]`.
      */
-    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+    listLevels(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
         beginRoot = this.ensureNode(beginRoot);
         const levelsNodes = [];
         if (!beginRoot)
@@ -1389,7 +1395,7 @@ export class BinaryTree extends IterableEntryBase {
      * `callback` function on each node in the binary tree. The type of the array nodes is determined
      * by the return type of the `callback` function.
      */
-    morris(callback = this._defaultOneParamCallback, pattern = 'IN', beginRoot = this.root) {
+    morris(callback = this._DEFAULT_CALLBACK, pattern = 'IN', beginRoot = this.root) {
         beginRoot = this.ensureNode(beginRoot);
         if (beginRoot === null)
             return [];
@@ -1700,7 +1706,7 @@ export class BinaryTree extends IterableEntryBase {
             ];
         }
     }
-    _defaultOneParamCallback = (node) => (node ? node.key : undefined);
+    _DEFAULT_CALLBACK = (node) => (node ? node.key : undefined);
     /**
      * Swap the data of two nodes in the binary tree.
      * @param {NODE} srcNode - The source node to swap.

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

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BSTNested, BSTNodeNested, BSTOptions, BTNCallback, KeyOrNodeOrEntry } from '../../types';
-import { BSTVariant, CP, DFSOrderPattern, IterationType } from '../../types';
+import { BSTNKeyOrNode, BSTVariant, CP, DFSOrderPattern, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 export declare class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNodeNested<K, V>> extends BinaryTreeNode<K, V, NODE> {
@@ -209,6 +209,32 @@ export declare class BST<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BS
      * @returns The method returns an array of nodes (`NODE[]`).
      */
     getNodes<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The `getNode` function retrieves a node from a Red-Black Tree based on the provided identifier and
+     * callback function.
+     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value or key
+     * that you want to search for in the binary search tree. It can be of any type that is compatible
+     * with the type of nodes in the tree.
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
+     * the tree. It is used to determine whether a node matches the given identifier. The `callback`
+     * function should take a node as its parameter and return a value that can be compared to the
+     * `identifier` parameter.
+     * @param beginRoot - The `beginRoot` parameter is the starting point for the search in the binary
+     * search tree. It can be either a key or a node. If it is a key, it will be converted to a node
+     * using the `ensureNode` method. If it is not provided, the `root`
+     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+     * be performed when searching for nodes in the binary search tree. It is an optional parameter and
+     * its default value is taken from the `iterationType` property of the class.
+     * @returns The method is returning a value of type `NODE | null | undefined`.
+     */
+    getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, beginRoot?: BSTNKeyOrNode<K, NODE>, iterationType?: IterationType): NODE | undefined;
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)