min-heap-typed 1.41.0 → 1.41.1

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

@@ -177,9 +177,12 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     has<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N, iterationType?: IterationType): boolean;
     has<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N, iterationType?: IterationType): boolean;
     has<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C, beginRoot?: N, iterationType?: IterationType): boolean;
-    get<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N, iterationType?: IterationType): N | null;
-    get<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N, iterationType?: IterationType): N | null;
-    get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N, iterationType?: IterationType): N | null;
+    getNode<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N, iterationType?: IterationType): N | null;
+    getNode<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N, iterationType?: IterationType): N | null;
+    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N, iterationType?: IterationType): N | null;
+    get<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N, iterationType?: IterationType): V | undefined;
     /**
      * The function `getPathToRoot` returns an array of nodes starting from a given node and traversing
      * up to the root node, with the option to reverse the order of the nodes.

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

@@ -171,7 +171,7 @@ class BinaryTree {
             return;
         }
         const key = typeof keyOrNode === 'number' ? keyOrNode : keyOrNode ? keyOrNode.key : undefined;
-        const existNode = key !== undefined ? this.get(key, (node) => node.key) : undefined;
+        const existNode = key !== undefined ? this.getNode(key, (node) => node.key) : undefined;
         if (this.root) {
             if (existNode) {
                 existNode.value = value;
@@ -249,7 +249,7 @@ class BinaryTree {
             return bstDeletedResult;
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
-        const curr = this.get(identifier, callback);
+        const curr = this.getNode(identifier, callback);
         if (!curr)
             return bstDeletedResult;
         const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
@@ -302,9 +302,9 @@ class BinaryTree {
      */
     getDepth(distNode, beginRoot = this.root) {
         if (typeof distNode === 'number')
-            distNode = this.get(distNode);
+            distNode = this.getNode(distNode);
         if (typeof beginRoot === 'number')
-            beginRoot = this.get(beginRoot);
+            beginRoot = this.getNode(beginRoot);
         let depth = 0;
         while (distNode === null || distNode === void 0 ? void 0 : distNode.parent) {
             if (distNode === beginRoot) {
@@ -329,7 +329,7 @@ class BinaryTree {
      */
     getHeight(beginRoot = this.root, iterationType = this.iterationType) {
         if (typeof beginRoot === 'number')
-            beginRoot = this.get(beginRoot);
+            beginRoot = this.getNode(beginRoot);
         if (!beginRoot)
             return -1;
         if (iterationType === types_1.IterationType.RECURSIVE) {
@@ -521,13 +521,35 @@ class BinaryTree {
      * performed when searching for a node in the binary tree. It can have one of the following values:
      * @returns either the found node (of type N) or null if no node is found.
      */
-    get(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+    getNode(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
         // TODO may support finding node by value equal
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
     }
+    /**
+     * The function `get` returns the first node value in a binary tree that matches the given property or key.
+     * @param {BTNKey | N} identifier - The `identifier` parameter is the key or value of
+     * the node that you want to find in the binary tree. It can be either a `BTNKey` or `N`
+     * type.
+     * @param callback - The `callback` parameter is a function that is used to determine whether a node
+     * matches the desired criteria. It takes a node as input and returns a boolean value indicating
+     * whether the node matches the criteria or not. The default callback function
+     * (`((node: N) => node.key)`) is used if no callback function is
+     * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
+     * the root node from which the search should begin.
+     * @param iterationType - The `iterationType` parameter specifies the type of iteration to be
+     * performed when searching for a node in the binary tree. It can have one of the following values:
+     * @returns either the found value (of type V) or undefined if no node value is found.
+     */
+    get(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+        var _a;
+        if (identifier instanceof BinaryTreeNode)
+            callback = (node => node);
+        // TODO may support finding node by value equal
+        return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0].value) !== null && _a !== void 0 ? _a : undefined;
+    }
     /**
      * The function `getPathToRoot` returns an array of nodes starting from a given node and traversing
      * up to the root node, with the option to reverse the order of the nodes.
@@ -563,7 +585,7 @@ class BinaryTree {
      */
     getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
         if (typeof beginRoot === 'number')
-            beginRoot = this.get(beginRoot);
+            beginRoot = this.getNode(beginRoot);
         if (!beginRoot)
             return beginRoot;
         if (iterationType === types_1.IterationType.RECURSIVE) {
@@ -686,7 +708,7 @@ class BinaryTree {
      */
     subTreeTraverse(callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
         if (typeof beginRoot === 'number')
-            beginRoot = this.get(beginRoot);
+            beginRoot = this.getNode(beginRoot);
         const ans = [];
         if (!beginRoot)
             return ans;

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

@@ -72,7 +72,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @returns either the first node that matches the given nodeProperty and callback, or null if no
      * matching node is found.
      */
-    get<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
+    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
     /**
      * The function `lastKey` returns the key of the rightmost node if the comparison result is less
      * than, the key of the leftmost node if the comparison result is greater than, and the key of the

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

@@ -223,7 +223,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns either the first node that matches the given nodeProperty and callback, or null if no
      * matching node is found.
      */
-    get(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+    getNode(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
     }
@@ -347,7 +347,7 @@ class BST extends binary_tree_1.BinaryTree {
      */
     lesserOrGreaterTraverse(callback = ((node) => node.key), lesserOrGreater = types_1.CP.lt, targetNode = this.root, iterationType = this.iterationType) {
         if (typeof targetNode === 'number')
-            targetNode = this.get(targetNode);
+            targetNode = this.getNode(targetNode);
         const ans = [];
         if (!targetNode)
             return ans;

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

@@ -1,17 +1,17 @@
+import { RBTNColor } from '../../types';
 export declare class RBTreeNode {
     key: number;
     parent: RBTreeNode;
     left: RBTreeNode;
     right: RBTreeNode;
     color: number;
-    constructor();
+    constructor(key: number, color?: RBTNColor);
 }
+export declare const SN: RBTreeNode;
 export declare class RedBlackTree {
     constructor();
     protected _root: RBTreeNode;
     get root(): RBTreeNode;
-    protected _NIL: RBTreeNode;
-    get NIL(): RBTreeNode;
     /**
      * The `insert` function inserts a new node with a given key into a red-black tree and fixes any
      * violations of the red-black tree properties.
@@ -28,6 +28,7 @@ export declare class RedBlackTree {
      * @returns The `delete` function does not return anything. It has a return type of `void`.
      */
     delete(key: number): void;
+    isRealNode(node: RBTreeNode): node is RBTreeNode;
     /**
      * The function `getNode` is a recursive depth-first search algorithm that searches for a node with a
      * given key in a red-black tree.
@@ -45,7 +46,7 @@ export declare class RedBlackTree {
      * a Red-Black Tree.
      * @returns The leftmost node in the given RBTreeNode.
      */
-    getLeftMost(node: RBTreeNode): RBTreeNode;
+    getLeftMost(node?: RBTreeNode): RBTreeNode;
     /**
      * The function returns the rightmost node in a red-black tree.
      * @param {RBTreeNode} node - The parameter "node" is of type RBTreeNode.

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

@@ -1,31 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedBlackTree = exports.RBTreeNode = void 0;
+exports.RedBlackTree = exports.SN = exports.RBTreeNode = void 0;
 const types_1 = require("../../types");
 class RBTreeNode {
-    constructor() {
-        this.key = 0;
+    constructor(key, color = types_1.RBTNColor.BLACK) {
         this.color = types_1.RBTNColor.BLACK;
+        this.key = key;
+        this.color = color;
         this.parent = null;
         this.left = null;
         this.right = null;
     }
 }
 exports.RBTreeNode = RBTreeNode;
+exports.SN = new RBTreeNode(0);
 class RedBlackTree {
     constructor() {
-        this._NIL = new RBTreeNode();
-        this.NIL.color = types_1.RBTNColor.BLACK;
-        this.NIL.left = null;
-        this.NIL.right = null;
-        this._root = this.NIL;
+        this._root = exports.SN;
     }
     get root() {
         return this._root;
     }
-    get NIL() {
-        return this._NIL;
-    }
     /**
      * The `insert` function inserts a new node with a given key into a red-black tree and fixes any
      * violations of the red-black tree properties.
@@ -34,15 +29,12 @@ class RedBlackTree {
      * @returns The function does not explicitly return anything.
      */
     insert(key) {
-        const node = new RBTreeNode();
-        node.parent = null;
-        node.key = key;
-        node.left = this.NIL;
-        node.right = this.NIL;
-        node.color = types_1.RBTNColor.RED;
+        const node = new RBTreeNode(key, types_1.RBTNColor.RED);
+        node.left = exports.SN;
+        node.right = exports.SN;
         let y = null;
         let x = this.root;
-        while (x !== this.NIL) {
+        while (x !== exports.SN) {
             y = x;
             if (node.key < x.key) {
                 x = x.left;
@@ -79,9 +71,9 @@ class RedBlackTree {
      */
     delete(key) {
         const helper = (node) => {
-            let z = this.NIL;
+            let z = exports.SN;
             let x, y;
-            while (node !== this.NIL) {
+            while (node !== exports.SN) {
                 if (node.key === key) {
                     z = node;
                 }
@@ -92,17 +84,16 @@ class RedBlackTree {
                     node = node.left;
                 }
             }
-            if (z === this.NIL) {
-                console.log("Couldn't find key in the tree");
+            if (z === exports.SN) {
                 return;
             }
             y = z;
             let yOriginalColor = y.color;
-            if (z.left === this.NIL) {
+            if (z.left === exports.SN) {
                 x = z.right;
                 this._rbTransplant(z, z.right);
             }
-            else if (z.right === this.NIL) {
+            else if (z.right === exports.SN) {
                 x = z.left;
                 this._rbTransplant(z, z.left);
             }
@@ -123,12 +114,15 @@ class RedBlackTree {
                 y.left.parent = y;
                 y.color = z.color;
             }
-            if (yOriginalColor === 0) {
+            if (yOriginalColor === types_1.RBTNColor.BLACK) {
                 this._fixDelete(x);
             }
         };
         helper(this.root);
     }
+    isRealNode(node) {
+        return node !== exports.SN && node !== null;
+    }
     /**
      * The function `getNode` is a recursive depth-first search algorithm that searches for a node with a
      * given key in a red-black tree.
@@ -141,13 +135,17 @@ class RedBlackTree {
      */
     getNode(key, beginRoot = this.root) {
         const dfs = (node) => {
-            if (node === this.NIL || key === node.key) {
-                return node;
+            if (this.isRealNode(node)) {
+                if (key === node.key) {
+                    return node;
+                }
+                if (key < node.key)
+                    return dfs(node.left);
+                return dfs(node.right);
             }
-            if (key < node.key) {
-                return dfs(node.left);
+            else {
+                return null;
             }
-            return dfs(node.right);
         };
         return dfs(beginRoot);
     }
@@ -157,8 +155,8 @@ class RedBlackTree {
      * a Red-Black Tree.
      * @returns The leftmost node in the given RBTreeNode.
      */
-    getLeftMost(node) {
-        while (node.left !== null && node.left !== this.NIL) {
+    getLeftMost(node = this.root) {
+        while (node.left !== null && node.left !== exports.SN) {
             node = node.left;
         }
         return node;
@@ -169,7 +167,7 @@ class RedBlackTree {
      * @returns the rightmost node in a red-black tree.
      */
     getRightMost(node) {
-        while (node.right !== null && node.right !== this.NIL) {
+        while (node.right !== null && node.right !== exports.SN) {
             node = node.right;
         }
         return node;
@@ -180,11 +178,11 @@ class RedBlackTree {
      * @returns the successor of the given RBTreeNode.
      */
     getSuccessor(x) {
-        if (x.right !== this.NIL) {
+        if (x.right !== exports.SN) {
             return this.getLeftMost(x.right);
         }
         let y = x.parent;
-        while (y !== this.NIL && y !== null && x === y.right) {
+        while (y !== exports.SN && y !== null && x === y.right) {
             x = y;
             y = y.parent;
         }
@@ -197,11 +195,11 @@ class RedBlackTree {
      * @returns the predecessor of the given RBTreeNode 'x'.
      */
     getPredecessor(x) {
-        if (x.left !== this.NIL) {
+        if (x.left !== exports.SN) {
             return this.getRightMost(x.left);
         }
         let y = x.parent;
-        while (y !== this.NIL && x === y.left) {
+        while (y !== exports.SN && x === y.left) {
             x = y;
             y = y.parent;
         }
@@ -214,7 +212,7 @@ class RedBlackTree {
     _leftRotate(x) {
         const y = x.right;
         x.right = y.left;
-        if (y.left !== this.NIL) {
+        if (y.left !== exports.SN) {
             y.left.parent = x;
         }
         y.parent = x.parent;
@@ -238,7 +236,7 @@ class RedBlackTree {
     _rightRotate(x) {
         const y = x.left;
         x.left = y.right;
-        if (y.right !== this.NIL) {
+        if (y.right !== exports.SN) {
             y.right.parent = x;
         }
         y.parent = x.parent;
@@ -261,7 +259,7 @@ class RedBlackTree {
      */
     _fixDelete(x) {
         let s;
-        while (x !== this.root && x.color === 0) {
+        while (x !== this.root && x.color === types_1.RBTNColor.BLACK) {
             if (x === x.parent.left) {
                 s = x.parent.right;
                 if (s.color === 1) {
@@ -270,12 +268,12 @@ class RedBlackTree {
                     this._leftRotate(x.parent);
                     s = x.parent.right;
                 }
-                if (s.left.color === 0 && s.right.color === 0) {
+                if (s.left !== null && s.left.color === types_1.RBTNColor.BLACK && s.right.color === types_1.RBTNColor.BLACK) {
                     s.color = types_1.RBTNColor.RED;
                     x = x.parent;
                 }
                 else {
-                    if (s.right.color === 0) {
+                    if (s.right.color === types_1.RBTNColor.BLACK) {
                         s.left.color = types_1.RBTNColor.BLACK;
                         s.color = types_1.RBTNColor.RED;
                         this._rightRotate(s);
@@ -296,12 +294,12 @@ class RedBlackTree {
                     this._rightRotate(x.parent);
                     s = x.parent.left;
                 }
-                if (s.right.color === 0 && s.right.color === 0) {
+                if (s.right.color === types_1.RBTNColor.BLACK && s.right.color === types_1.RBTNColor.BLACK) {
                     s.color = types_1.RBTNColor.RED;
                     x = x.parent;
                 }
                 else {
-                    if (s.left.color === 0) {
+                    if (s.left.color === types_1.RBTNColor.BLACK) {
                         s.right.color = types_1.RBTNColor.BLACK;
                         s.color = types_1.RBTNColor.RED;
                         this._leftRotate(s);

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

@@ -159,7 +159,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             else if (parent.right === undefined) {
                 parent.right = newNode;
                 if (newNode !== null) {
-                    this._size = (this.size + 1);
+                    this._size = this.size + 1;
                     this._setCount(this.count + newNode.count);
                 }
                 return parent.right;
@@ -262,7 +262,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
-        const curr = this.get(identifier, callback);
+        const curr = this.getNode(identifier, callback);
         if (!curr)
             return bstDeletedResult;
         const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.41.0",
+  "version": "1.41.1",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -131,6 +131,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.41.0"
+    "data-structure-typed": "^1.41.1"
   }
 }

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

@@ -21,7 +21,8 @@ export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNeste
 
 export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTreeNodeNested<V>>>
   extends BST<V, N>
-  implements IBinaryTree<V, N> {
+  implements IBinaryTree<V, N>
+{
   /**
    * This is a constructor function for an AVL tree data structure in TypeScript.
    * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
@@ -160,7 +161,7 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
       // Balance Restoration: If a balance issue is discovered after inserting a node, it requires balance restoration operations. Balance restoration includes four basic cases where rotation operations need to be performed to fix the balance:
       switch (
         this._balanceFactor(A) // second O(1)
-        ) {
+      ) {
         case -2:
           if (A && A.left) {
             if (this._balanceFactor(A.left) <= 0) {

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

@@ -17,7 +17,7 @@ export class BinaryIndexedTree {
    * @param  - - `frequency`: The default frequency value. It is optional and has a default
    * value of 0.
    */
-  constructor({frequency = 0, max}: { frequency?: number; max: number }) {
+  constructor({frequency = 0, max}: {frequency?: number; max: number}) {
     this._freq = frequency;
     this._max = max;
     this._freqMap = {0: 0};

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

@@ -108,7 +108,8 @@ export class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = BinaryTree
  * @template N - The type of the binary tree's nodes.
  */
 export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>>
-  implements IBinaryTree<V, N> {
+  implements IBinaryTree<V, N>
+{
   iterationType: IterationType = IterationType.ITERATIVE;
 
   /**
@@ -201,7 +202,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     }
 
     const key = typeof keyOrNode === 'number' ? keyOrNode : keyOrNode ? keyOrNode.key : undefined;
-    const existNode = key !== undefined ? this.get(key, (node: N) => node.key) : undefined;
+    const existNode = key !== undefined ? this.getNode(key, (node: N) => node.key) : undefined;
 
     if (this.root) {
       if (existNode) {
@@ -290,7 +291,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     if (!this.root) return bstDeletedResult;
     if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
 
-    const curr = this.get(identifier, callback);
+    const curr = this.getNode(identifier, callback);
     if (!curr) return bstDeletedResult;
 
     const parent: N | null = curr?.parent ? curr.parent : null;
@@ -342,8 +343,8 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns the depth of the `distNode` relative to the `beginRoot`.
    */
   getDepth(distNode: BTNKey | N | null, beginRoot: BTNKey | N | null = this.root): number {
-    if (typeof distNode === 'number') distNode = this.get(distNode);
-    if (typeof beginRoot === 'number') beginRoot = this.get(beginRoot);
+    if (typeof distNode === 'number') distNode = this.getNode(distNode);
+    if (typeof beginRoot === 'number') beginRoot = this.getNode(beginRoot);
     let depth = 0;
     while (distNode?.parent) {
       if (distNode === beginRoot) {
@@ -368,7 +369,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns the height of the binary tree.
    */
   getHeight(beginRoot: BTNKey | N | null = this.root, iterationType = this.iterationType): number {
-    if (typeof beginRoot === 'number') beginRoot = this.get(beginRoot);
+    if (typeof beginRoot === 'number') beginRoot = this.getNode(beginRoot);
     if (!beginRoot) return -1;
 
     if (iterationType === IterationType.RECURSIVE) {
@@ -385,7 +386,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         return -1;
       }
 
-      const stack: { node: N; depth: number }[] = [{node: beginRoot, depth: 0}];
+      const stack: {node: N; depth: number}[] = [{node: beginRoot, depth: 0}];
       let maxHeight = 0;
 
       while (stack.length > 0) {
@@ -604,21 +605,21 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
   }
 
-  get<C extends BTNCallback<N, BTNKey>>(
+  getNode<C extends BTNCallback<N, BTNKey>>(
     identifier: BTNKey,
     callback?: C,
     beginRoot?: N,
     iterationType?: IterationType
   ): N | null;
 
-  get<C extends BTNCallback<N, N>>(
+  getNode<C extends BTNCallback<N, N>>(
     identifier: N | null,
     callback?: C,
     beginRoot?: N,
     iterationType?: IterationType
   ): N | null;
 
-  get<C extends BTNCallback<N>>(
+  getNode<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
     callback: C,
     beginRoot?: N,
@@ -640,7 +641,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * performed when searching for a node in the binary tree. It can have one of the following values:
    * @returns either the found node (of type N) or null if no node is found.
    */
-  get<C extends BTNCallback<N>>(
+  getNode<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
     callback: C = ((node: N) => node.key) as C,
     beginRoot = this.root,
@@ -651,6 +652,53 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
   }
 
+  get<C extends BTNCallback<N, BTNKey>>(
+    identifier: BTNKey,
+    callback?: C,
+    beginRoot?: N,
+    iterationType?: IterationType
+  ): V | undefined;
+
+  get<C extends BTNCallback<N, N>>(
+    identifier: N | null,
+    callback?: C,
+    beginRoot?: N,
+    iterationType?: IterationType
+  ): V | undefined;
+
+  get<C extends BTNCallback<N>>(
+    identifier: ReturnType<C>,
+    callback: C,
+    beginRoot?: N,
+    iterationType?: IterationType
+  ): V | undefined;
+
+  /**
+   * The function `get` returns the first node value in a binary tree that matches the given property or key.
+   * @param {BTNKey | N} identifier - The `identifier` parameter is the key or value of
+   * the node that you want to find in the binary tree. It can be either a `BTNKey` or `N`
+   * type.
+   * @param callback - The `callback` parameter is a function that is used to determine whether a node
+   * matches the desired criteria. It takes a node as input and returns a boolean value indicating
+   * whether the node matches the criteria or not. The default callback function
+   * (`((node: N) => node.key)`) is used if no callback function is
+   * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
+   * the root node from which the search should begin.
+   * @param iterationType - The `iterationType` parameter specifies the type of iteration to be
+   * performed when searching for a node in the binary tree. It can have one of the following values:
+   * @returns either the found value (of type V) or undefined if no node value is found.
+   */
+  get<C extends BTNCallback<N>>(
+    identifier: ReturnType<C> | null,
+    callback: C = ((node: N) => node.key) as C,
+    beginRoot = this.root,
+    iterationType = this.iterationType
+  ): V | undefined {
+    if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
+    // TODO may support finding node by value equal
+    return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0].value ?? undefined;
+  }
+
   /**
    * The function `getPathToRoot` returns an array of nodes starting from a given node and traversing
    * up to the root node, with the option to reverse the order of the nodes.
@@ -686,7 +734,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * no leftmost node, it returns `null`.
    */
   getLeftMost(beginRoot: BTNKey | N | null = this.root, iterationType = this.iterationType): N | null {
-    if (typeof beginRoot === 'number') beginRoot = this.get(beginRoot);
+    if (typeof beginRoot === 'number') beginRoot = this.getNode(beginRoot);
 
     if (!beginRoot) return beginRoot;
 
@@ -812,7 +860,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     beginRoot: BTNKey | N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
-    if (typeof beginRoot === 'number') beginRoot = this.get(beginRoot);
+    if (typeof beginRoot === 'number') beginRoot = this.getNode(beginRoot);
 
     const ans: ReturnType<BTNCallback<N>>[] = [];
     if (!beginRoot) return ans;
@@ -888,7 +936,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
       _traverse(beginRoot);
     } else {
       // 0: visit, 1: print
-      const stack: { opt: 0 | 1; node: N | null | undefined }[] = [{opt: 0, node: beginRoot}];
+      const stack: {opt: 0 | 1; node: N | null | undefined}[] = [{opt: 0, node: beginRoot}];
 
       while (stack.length > 0) {
         const cur = stack.pop();
@@ -960,7 +1008,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         if (current.right) queue.push(current.right);
 
         traverse(level + 1);
-      }
+      };
 
       traverse(0);
     } else {
@@ -1055,7 +1103,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The function `getSuccessor` returns a value of type `N` (the successor node), or `null`
    * if there is no successor, or `undefined` if the input `x` is `undefined`.
    */
-  getSuccessor(x: N): N | null | undefined{
+  getSuccessor(x: N): N | null | undefined {
     if (x.right) {
       return this.getLeftMost(x.right);
     }
@@ -1178,7 +1226,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The `*[Symbol.iterator]` method returns a generator object that yields the keys of the
    * binary tree nodes in a specific order.
    */
-  * [Symbol.iterator](node = this.root): Generator<BTNKey, void, undefined> {
+  *[Symbol.iterator](node = this.root): Generator<BTNKey, void, undefined> {
     if (!node) {
       return;
     }