bst-typed 1.51.0 → 1.51.2

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

@@ -165,19 +165,19 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns either a node object (NODE) or undefined.
      */
     ensureNode(keyOrNodeOrEntry, iterationType = 'ITERATIVE') {
-        let res;
         if (this.isRealNode(keyOrNodeOrEntry)) {
-            res = keyOrNodeOrEntry;
+            return keyOrNodeOrEntry;
         }
         else if (this.isEntry(keyOrNodeOrEntry)) {
-            if (keyOrNodeOrEntry[0])
-                res = this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
+            if (keyOrNodeOrEntry[0] === null || keyOrNodeOrEntry[0] === undefined)
+                return;
+            return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
         }
         else {
-            if (keyOrNodeOrEntry)
-                res = this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+            if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === undefined)
+                return;
+            return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
         }
-        return res;
     }
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
@@ -361,33 +361,33 @@ class BST extends binary_tree_1.BinaryTree {
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
     getNodeByKey(key, iterationType = 'ITERATIVE') {
-        // return this.getNodes(key, this._defaultOneParamCallback, true, this.root, iterationType)[0];
+        // return this.getNodes(key, this._DEFAULT_CALLBACK, true, this.root, iterationType)[0];
         if (!this.isRealNode(this.root))
-            return undefined;
+            return;
         if (iterationType === 'RECURSIVE') {
-            const _dfs = (cur) => {
+            const dfs = (cur) => {
                 if (cur.key === key)
                     return cur;
                 if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
-                if (this._compare(cur.key, key) === 'GT' && this.isRealNode(cur.left))
-                    return _dfs(cur.left);
-                if (this._compare(cur.key, key) === 'LT' && this.isRealNode(cur.right))
-                    return _dfs(cur.right);
+                if (this.isRealNode(cur.left) && this._compare(cur.key, key) === 'GT')
+                    return dfs(cur.left);
+                if (this.isRealNode(cur.right) && this._compare(cur.key, key) === 'LT')
+                    return dfs(cur.right);
             };
-            return _dfs(this.root);
+            return dfs(this.root);
         }
         else {
-            const queue = new queue_1.Queue([this.root]);
-            while (queue.size > 0) {
-                const cur = queue.shift();
+            const stack = [this.root];
+            while (stack.length > 0) {
+                const cur = stack.pop();
                 if (this.isRealNode(cur)) {
                     if (this._compare(cur.key, key) === 'EQ')
                         return cur;
-                    if (this._compare(cur.key, key) === 'GT')
-                        this.isRealNode(cur.left) && queue.push(cur.left);
-                    if (this._compare(cur.key, key) === 'LT')
-                        this.isRealNode(cur.right) && queue.push(cur.right);
+                    if (this.isRealNode(cur.left) && this._compare(cur.key, key) === 'GT')
+                        stack.push(cur.left);
+                    if (this.isRealNode(cur.right) && this._compare(cur.key, key) === 'LT')
+                        stack.push(cur.right);
                 }
             }
         }
@@ -420,13 +420,13 @@ class BST extends binary_tree_1.BinaryTree {
      * performed on the binary tree. It can have two possible values:
      * @returns The method returns an array of nodes (`NODE[]`).
      */
-    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+    getNodes(identifier, callback = this._DEFAULT_CALLBACK, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
         const ans = [];
         if (iterationType === 'RECURSIVE') {
-            const _traverse = (cur) => {
+            const dfs = (cur) => {
                 const callbackResult = callback(cur);
                 if (callbackResult === identifier) {
                     ans.push(cur);
@@ -436,18 +436,18 @@ class BST extends binary_tree_1.BinaryTree {
                 if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
                 // TODO potential bug
-                if (callback === this._defaultOneParamCallback) {
+                if (callback === this._DEFAULT_CALLBACK) {
                     if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === 'GT')
-                        _traverse(cur.left);
+                        dfs(cur.left);
                     if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === 'LT')
-                        _traverse(cur.right);
+                        dfs(cur.right);
                 }
                 else {
-                    this.isRealNode(cur.left) && _traverse(cur.left);
-                    this.isRealNode(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 stack = [beginRoot];
@@ -461,7 +461,7 @@ class BST extends binary_tree_1.BinaryTree {
                             return ans;
                     }
                     // TODO potential bug
-                    if (callback === this._defaultOneParamCallback) {
+                    if (callback === this._DEFAULT_CALLBACK) {
                         if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === 'LT')
                             stack.push(cur.right);
                         if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === 'GT')
@@ -482,6 +482,35 @@ class BST extends binary_tree_1.BinaryTree {
         }
         return ans;
     }
+    /**
+     * 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(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
+        var _a;
+        return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -505,7 +534,7 @@ class BST extends binary_tree_1.BinaryTree {
      * following values:
      * @returns The method is returning an array of the return type of the callback function.
      */
-    dfs(callback = this._defaultOneParamCallback, pattern = 'IN', beginRoot = this.root, iterationType = 'ITERATIVE') {
+    dfs(callback = this._DEFAULT_CALLBACK, pattern = 'IN', beginRoot = this.root, iterationType = 'ITERATIVE') {
         return super.dfs(callback, pattern, beginRoot, iterationType, false);
     }
     /**
@@ -529,7 +558,7 @@ class BST extends binary_tree_1.BinaryTree {
      * nodes are visited.
      * @returns The method is returning an array of the return type of the callback function.
      */
-    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    bfs(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
         return super.bfs(callback, beginRoot, iterationType, false);
     }
     /**
@@ -554,7 +583,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns The method is returning a two-dimensional array of the return type of the callback
      * function.
      */
-    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    listLevels(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
         return super.listLevels(callback, beginRoot, iterationType, false);
     }
     /**
@@ -617,7 +646,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = 'LT', targetNode = this.root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = this._DEFAULT_CALLBACK, lesserOrGreater = 'LT', targetNode = this.root, iterationType = this.iterationType) {
         targetNode = this.ensureNode(targetNode);
         const ans = [];
         if (!targetNode)
@@ -626,16 +655,16 @@ class BST extends binary_tree_1.BinaryTree {
             return ans;
         const targetKey = targetNode.key;
         if (iterationType === 'RECURSIVE') {
-            const _traverse = (cur) => {
+            const dfs = (cur) => {
                 const compared = this._compare(cur.key, targetKey);
                 if (compared === lesserOrGreater)
                     ans.push(callback(cur));
                 if (this.isRealNode(cur.left))
-                    _traverse(cur.left);
+                    dfs(cur.left);
                 if (this.isRealNode(cur.right))
-                    _traverse(cur.right);
+                    dfs(cur.right);
             };
-            _traverse(this.root);
+            dfs(this.root);
             return ans;
         }
         else {

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

@@ -1,4 +1,4 @@
-import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, IterationType, KeyOrNodeOrEntry, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
+import type { BinaryTreeDeleteResult, BTNCallback, KeyOrNodeOrEntry, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { CRUD, RBTNColor } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
@@ -39,12 +39,6 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * should compare keys and
      */
     constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: RBTreeOptions<K>);
-    protected _SENTINEL: NODE;
-    /**
-     * The function returns the value of the _SENTINEL property.
-     * @returns The method is returning the value of the `_SENTINEL` property.
-     */
-    get SENTINEL(): NODE;
     protected _root: NODE | undefined;
     /**
      * The function returns the root node of a tree or undefined if there is no root.
@@ -101,46 +95,6 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * @returns {boolean} - `true` if the object is a Red-Black Tree node, `false` otherwise.
      */
     isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is NODE;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function checks if a given node is a real node in a Red-Black Tree.
-     * @param {NODE | undefined} node - The `node` parameter is of type `NODE | undefined`, which means
-     * it can either be of type `NODE` or `undefined`.
-     * @returns a boolean value.
-     */
-    isRealNode(node: NODE | undefined): node is 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 | null | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -187,7 +141,7 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * deleted is not found.
      * @param {C} callback - The `callback` parameter is a function that is used to retrieve a node from
      * the binary tree based on its identifier. It is an optional parameter and if not provided, the
-     * `_defaultOneParamCallback` function is used as the default callback. The callback function should
+     * `_DEFAULT_CALLBACK` function is used as the default callback. The callback function should
      * return the identifier of the node to
      * @returns an array of BinaryTreeDeleteResult<NODE> objects.
      */

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

@@ -47,19 +47,11 @@ class RedBlackTree extends bst_1.BST {
      */
     constructor(keysOrNodesOrEntries = [], options) {
         super([], options);
-        this._SENTINEL = new RedBlackTreeNode(NaN);
-        this._root = this.SENTINEL;
+        this._root = this.NIL;
         if (keysOrNodesOrEntries) {
             this.addMany(keysOrNodesOrEntries);
         }
     }
-    /**
-     * The function returns the value of the _SENTINEL property.
-     * @returns The method is returning the value of the `_SENTINEL` property.
-     */
-    get SENTINEL() {
-        return this._SENTINEL;
-    }
     /**
      * The function returns the root node of a tree or undefined if there is no root.
      * @returns The root node of the tree structure, or undefined if there is no root node.
@@ -147,53 +139,6 @@ class RedBlackTree extends bst_1.BST {
     isNode(keyOrNodeOrEntry) {
         return keyOrNodeOrEntry instanceof RedBlackTreeNode;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function checks if a given node is a real node in a Red-Black Tree.
-     * @param {NODE | undefined} node - The `node` parameter is of type `NODE | undefined`, which means
-     * it can either be of type `NODE` or `undefined`.
-     * @returns a boolean value.
-     */
-    isRealNode(node) {
-        if (node === this.SENTINEL || node === undefined)
-            return false;
-        return node instanceof RedBlackTreeNode;
-    }
-    /**
-     * 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(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
-        var _a;
-        return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -207,7 +152,7 @@ class RedBlackTree extends bst_1.BST {
      */
     clear() {
         super.clear();
-        this._root = this.SENTINEL;
+        this._root = this.NIL;
     }
     /**
      * Time Complexity: O(log n)
@@ -261,11 +206,11 @@ class RedBlackTree extends bst_1.BST {
      * deleted is not found.
      * @param {C} callback - The `callback` parameter is a function that is used to retrieve a node from
      * the binary tree based on its identifier. It is an optional parameter and if not provided, the
-     * `_defaultOneParamCallback` function is used as the default callback. The callback function should
+     * `_DEFAULT_CALLBACK` function is used as the default callback. The callback function should
      * return the identifier of the node to
      * @returns an array of BinaryTreeDeleteResult<NODE> objects.
      */
-    delete(identifier, callback = this._defaultOneParamCallback) {
+    delete(identifier, callback = this._DEFAULT_CALLBACK) {
         if (identifier === null)
             return [];
         const results = [];
@@ -369,10 +314,10 @@ class RedBlackTree extends bst_1.BST {
         while (this.isRealNode(current)) {
             parent = current;
             if (node.key < current.key) {
-                current = (_a = current.left) !== null && _a !== void 0 ? _a : this.SENTINEL;
+                current = (_a = current.left) !== null && _a !== void 0 ? _a : this.NIL;
             }
             else if (node.key > current.key) {
-                current = (_b = current.right) !== null && _b !== void 0 ? _b : this.SENTINEL;
+                current = (_b = current.right) !== null && _b !== void 0 ? _b : this.NIL;
             }
             else {
                 this._replaceNode(current, node);
@@ -389,8 +334,8 @@ class RedBlackTree extends bst_1.BST {
         else {
             parent.right = node;
         }
-        node.left = this.SENTINEL;
-        node.right = this.SENTINEL;
+        node.left = this.NIL;
+        node.right = this.NIL;
         node.color = 'RED';
         this._insertFixup(node);
         return 'CREATED';

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

@@ -145,7 +145,7 @@ export declare class TreeMultiMap<K = any, V = any, NODE extends TreeMultiMapNod
      * function. It can also be null or undefined if no node needs to be deleted.
      * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
      * input and returns a value of type `ReturnType<C>`. It is used to determine if a node matches the
-     * identifier for deletion. If no callback is provided, the `_defaultOneParamCallback` function is
+     * identifier for deletion. If no callback is provided, the `_DEFAULT_CALLBACK` function is
      * used
      * @param [ignoreCount=false] - A boolean value indicating whether to ignore the count of the target
      * node when performing deletion. If set to true, the count of the target node will not be considered

package/dist/data-structures/binary-tree/tree-multi-map.js

@@ -198,7 +198,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * function. It can also be null or undefined if no node needs to be deleted.
      * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
      * input and returns a value of type `ReturnType<C>`. It is used to determine if a node matches the
-     * identifier for deletion. If no callback is provided, the `_defaultOneParamCallback` function is
+     * identifier for deletion. If no callback is provided, the `_DEFAULT_CALLBACK` function is
      * used
      * @param [ignoreCount=false] - A boolean value indicating whether to ignore the count of the target
      * node when performing deletion. If set to true, the count of the target node will not be considered
@@ -206,7 +206,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * target node will be decremented
      * @returns an array of BinaryTreeDeleteResult<NODE> objects.
      */
-    delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
+    delete(identifier, callback = this._DEFAULT_CALLBACK, ignoreCount = false) {
         if (identifier === null)
             return [];
         const results = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bst-typed",
-  "version": "1.51.0",
+  "version": "1.51.2",
   "description": "BST (Binary Search Tree). Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -144,6 +144,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.51.0"
+    "data-structure-typed": "^1.51.2"
   }
 }

package/src/data-structures/binary-tree/avl-tree-multi-map.ts

@@ -240,7 +240,7 @@ export class AVLTreeMultiMap<
    */
   override delete<C extends BTNCallback<NODE>>(
     identifier: ReturnType<C>,
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     ignoreCount = false
   ): BinaryTreeDeleteResult<NODE>[] {
     const deletedResult: BinaryTreeDeleteResult<NODE>[] = [];

package/src/data-structures/binary-tree/avl-tree.ts

@@ -164,13 +164,13 @@ export class AVLTree<
    * `callback` function.
    * @param {C} callback - The `callback` parameter is a function that will be called for each node
    * that is deleted from the binary tree. It is an optional parameter and if not provided, it will
-   * default to the `_defaultOneParamCallback` function. The `callback` function should have a single
+   * default to the `_DEFAULT_CALLBACK` function. The `callback` function should have a single
    * parameter of type `NODE
    * @returns The method is returning an array of `BinaryTreeDeleteResult<NODE>`.
    */
   override delete<C extends BTNCallback<NODE>>(
     identifier: ReturnType<C>,
-    callback: C = this._defaultOneParamCallback as C
+    callback: C = this._DEFAULT_CALLBACK as C
   ): BinaryTreeDeleteResult<NODE>[] {
     if ((identifier as any) instanceof AVLTreeNode) callback = (node => node) as C;
     const deletedResults = super.delete(identifier, callback);