min-heap-typed 1.41.0 → 1.41.2

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

@@ -174,12 +174,15 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     getNodes<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
     getNodes<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
     getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
-    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;
+    has<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C, beginRoot?: N | null, iterationType?: IterationType): boolean;
+    getNode<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
+    getNode<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
+    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
+    get<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | null, 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) {
@@ -503,7 +503,6 @@ class BinaryTree {
     has(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
-        // TODO may support finding node by value equal
         return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
     }
     /**
@@ -521,13 +520,33 @@ 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, _b;
+        if (identifier instanceof BinaryTreeNode)
+            callback = (node => node);
+        return (_b = (_a = this.getNode(identifier, callback, beginRoot, iterationType)) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : 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 +582,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 +705,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,31 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+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 NIL: RBTreeNode;
+/**
+ * 1. Each node is either red or black.
+ * 2. The root node is always black.
+ * 3. Leaf nodes are typically NIL nodes and are considered black.
+ * 4. Red nodes must have black children.
+ * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
+ */
 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 +42,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 | null | undefined): 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 +60,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.
@@ -65,6 +80,7 @@ export declare class RedBlackTree {
      * @returns the predecessor of the given RBTreeNode 'x'.
      */
     getPredecessor(x: RBTreeNode): RBTreeNode;
+    print(beginRoot?: RBTreeNode): void;
     /**
      * The function performs a left rotation on a red-black tree node.
      * @param {RBTreeNode} x - The parameter `x` is a RBTreeNode object.

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

@@ -1,31 +1,40 @@
 "use strict";
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedBlackTree = exports.RBTreeNode = void 0;
+exports.RedBlackTree = exports.NIL = 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.NIL = new RBTreeNode(0);
+/**
+ * 1. Each node is either red or black.
+ * 2. The root node is always black.
+ * 3. Leaf nodes are typically NIL nodes and are considered black.
+ * 4. Red nodes must have black children.
+ * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
+ */
 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.NIL;
     }
     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 +43,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.NIL;
+        node.right = exports.NIL;
         let y = null;
         let x = this.root;
-        while (x !== this.NIL) {
+        while (x !== exports.NIL) {
             y = x;
             if (node.key < x.key) {
                 x = x.left;
@@ -79,9 +85,9 @@ class RedBlackTree {
      */
     delete(key) {
         const helper = (node) => {
-            let z = this.NIL;
+            let z = exports.NIL;
             let x, y;
-            while (node !== this.NIL) {
+            while (node !== exports.NIL) {
                 if (node.key === key) {
                     z = node;
                 }
@@ -92,17 +98,16 @@ class RedBlackTree {
                     node = node.left;
                 }
             }
-            if (z === this.NIL) {
-                console.log("Couldn't find key in the tree");
+            if (z === exports.NIL) {
                 return;
             }
             y = z;
             let yOriginalColor = y.color;
-            if (z.left === this.NIL) {
+            if (z.left === exports.NIL) {
                 x = z.right;
                 this._rbTransplant(z, z.right);
             }
-            else if (z.right === this.NIL) {
+            else if (z.right === exports.NIL) {
                 x = z.left;
                 this._rbTransplant(z, z.left);
             }
@@ -123,12 +128,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.NIL && 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 +149,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 +169,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.NIL) {
             node = node.left;
         }
         return node;
@@ -169,7 +181,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.NIL) {
             node = node.right;
         }
         return node;
@@ -180,11 +192,11 @@ class RedBlackTree {
      * @returns the successor of the given RBTreeNode.
      */
     getSuccessor(x) {
-        if (x.right !== this.NIL) {
+        if (x.right !== exports.NIL) {
             return this.getLeftMost(x.right);
         }
         let y = x.parent;
-        while (y !== this.NIL && y !== null && x === y.right) {
+        while (y !== exports.NIL && y !== null && x === y.right) {
             x = y;
             y = y.parent;
         }
@@ -197,16 +209,69 @@ class RedBlackTree {
      * @returns the predecessor of the given RBTreeNode 'x'.
      */
     getPredecessor(x) {
-        if (x.left !== this.NIL) {
+        if (x.left !== exports.NIL) {
             return this.getRightMost(x.left);
         }
         let y = x.parent;
-        while (y !== this.NIL && x === y.left) {
+        while (y !== exports.NIL && x === y.left) {
             x = y;
             y = y.parent;
         }
         return y;
     }
+    print(beginRoot = this.root) {
+        const display = (root) => {
+            const [lines, , ,] = _displayAux(root);
+            for (const line of lines) {
+                console.log(line);
+            }
+        };
+        const _displayAux = (node) => {
+            if (node === null) {
+                return [[], 0, 0, 0];
+            }
+            if (node.right === null && node.left === null) {
+                const line = `${node.key}`;
+                const width = line.length;
+                const height = 1;
+                const middle = Math.floor(width / 2);
+                return [[line], width, height, middle];
+            }
+            if (node.right === null) {
+                const [lines, n, p, x] = _displayAux(node.left);
+                const s = `${node.key}`;
+                const u = s.length;
+                const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s;
+                const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u);
+                const shifted_lines = lines.map(line => line + ' '.repeat(u));
+                return [[first_line, second_line, ...shifted_lines], n + u, p + 2, n + Math.floor(u / 2)];
+            }
+            if (node.left === null) {
+                const [lines, n, p, u] = _displayAux(node.right);
+                const s = `${node.key}`;
+                const x = s.length;
+                const first_line = s + '_'.repeat(x) + ' '.repeat(n - x);
+                const second_line = ' '.repeat(u + x) + '\\' + ' '.repeat(n - x - 1);
+                const shifted_lines = lines.map(line => ' '.repeat(u) + line);
+                return [[first_line, second_line, ...shifted_lines], n + x, p + 2, Math.floor(u / 2)];
+            }
+            const [left, n, p, x] = _displayAux(node.left);
+            const [right, m, q, y] = _displayAux(node.right);
+            const s = `${node.key}`;
+            const u = s.length;
+            const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s + '_'.repeat(y) + ' '.repeat(m - y);
+            const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u + y) + '\\' + ' '.repeat(m - y - 1);
+            if (p < q) {
+                left.push(...new Array(q - p).fill(' '.repeat(n)));
+            }
+            else if (q < p) {
+                right.push(...new Array(p - q).fill(' '.repeat(m)));
+            }
+            const zipped_lines = left.map((a, i) => a + ' '.repeat(u) + right[i]);
+            return [[first_line, second_line, ...zipped_lines], n + m + u, Math.max(p, q) + 2, n + Math.floor(u / 2)];
+        };
+        display(beginRoot);
+    }
     /**
      * The function performs a left rotation on a red-black tree node.
      * @param {RBTreeNode} x - The parameter `x` is a RBTreeNode object.
@@ -214,7 +279,7 @@ class RedBlackTree {
     _leftRotate(x) {
         const y = x.right;
         x.right = y.left;
-        if (y.left !== this.NIL) {
+        if (y.left !== exports.NIL) {
             y.left.parent = x;
         }
         y.parent = x.parent;
@@ -238,7 +303,7 @@ class RedBlackTree {
     _rightRotate(x) {
         const y = x.left;
         x.left = y.right;
-        if (y.right !== this.NIL) {
+        if (y.right !== exports.NIL) {
             y.right.parent = x;
         }
         y.parent = x.parent;
@@ -261,7 +326,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 +335,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 +361,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.2",
   "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.2"
   }
 }

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};