data-structure-typed 1.38.0 → 1.38.2

package/{lib → dist/mjs}/data-structures/binary-tree/binary-indexed-tree.js

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryIndexedTree = void 0;
 /**
  * data-structure-typed
  *
@@ -5,8 +8,10 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { getMSB } from '../../utils';
-export class BinaryIndexedTree {
+const utils_1 = require("../../utils");
+class BinaryIndexedTree {
+    _freq;
+    _max;
     /**
      * The constructor initializes the properties of an object, including default frequency, maximum
      * value, a freqMap data structure, the most significant bit, and the count of negative frequencies.
@@ -17,21 +22,24 @@ export class BinaryIndexedTree {
         this._freq = frequency;
         this._max = max;
         this._freqMap = { 0: 0 };
-        this._msb = getMSB(max);
+        this._msb = (0, utils_1.getMSB)(max);
         this._negativeCount = frequency < 0 ? max : 0;
     }
+    _freqMap;
     get freqMap() {
         return this._freqMap;
     }
     set freqMap(value) {
         this._freqMap = value;
     }
+    _msb;
     get msb() {
         return this._msb;
     }
     set msb(value) {
         this._msb = value;
     }
+    _negativeCount;
     get negativeCount() {
         return this._negativeCount;
     }
@@ -255,3 +263,4 @@ export class BinaryIndexedTree {
         return left;
     }
 }
+exports.BinaryIndexedTree = BinaryIndexedTree;

package/{lib → dist/mjs}/data-structures/binary-tree/binary-tree.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * data-structure-typed
  *
@@ -5,15 +6,29 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { FamilyPosition, IterationType } from '../../types';
-import { trampoline } from '../../utils';
-import { Queue } from '../queue';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryTree = exports.BinaryTreeNode = void 0;
+const types_1 = require("../../types");
+const utils_1 = require("../../utils");
+const queue_1 = require("../queue");
 /**
  * Represents a node in a binary tree.
  * @template V - The type of data stored in the node.
  * @template FAMILY - The type of the family relationship in the binary tree.
  */
-export class BinaryTreeNode {
+class BinaryTreeNode {
+    /**
+     * The key associated with the node.
+     */
+    key;
+    /**
+     * The value stored in the node.
+     */
+    val;
+    /**
+     * The parent node of the current node.
+     */
+    parent;
     /**
      * Creates a new instance of BinaryTreeNode.
      * @param {BinaryTreeNodeKey} key - The key associated with the node.
@@ -23,6 +38,7 @@ export class BinaryTreeNode {
         this.key = key;
         this.val = val;
     }
+    _left;
     /**
      * Get the left child node.
      */
@@ -39,6 +55,7 @@ export class BinaryTreeNode {
         }
         this._left = v;
     }
+    _right;
     /**
      * Get the right child node.
      */
@@ -64,68 +81,59 @@ export class BinaryTreeNode {
         if (that.parent) {
             if (that.parent.left === that) {
                 if (that.left || that.right) {
-                    return FamilyPosition.ROOT_LEFT;
+                    return types_1.FamilyPosition.ROOT_LEFT;
                 }
                 else {
-                    return FamilyPosition.LEFT;
+                    return types_1.FamilyPosition.LEFT;
                 }
             }
             else if (that.parent.right === that) {
                 if (that.left || that.right) {
-                    return FamilyPosition.ROOT_RIGHT;
+                    return types_1.FamilyPosition.ROOT_RIGHT;
                 }
                 else {
-                    return FamilyPosition.RIGHT;
+                    return types_1.FamilyPosition.RIGHT;
                 }
             }
             else {
-                return FamilyPosition.MAL_NODE;
+                return types_1.FamilyPosition.MAL_NODE;
             }
         }
         else {
             if (that.left || that.right) {
-                return FamilyPosition.ROOT;
+                return types_1.FamilyPosition.ROOT;
             }
             else {
-                return FamilyPosition.ISOLATED;
+                return types_1.FamilyPosition.ISOLATED;
             }
         }
     }
 }
+exports.BinaryTreeNode = BinaryTreeNode;
 /**
  * Represents a binary tree data structure.
  * @template N - The type of the binary tree's nodes.
  */
-export class BinaryTree {
+class BinaryTree {
+    _loopType = types_1.IterationType.ITERATIVE;
     /**
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options) {
-        this._root = null;
-        this._size = 0;
-        this._loopType = IterationType.ITERATIVE;
-        this._defaultCallbackByKey = node => node.key;
         if (options !== undefined) {
-            const { iterationType = IterationType.ITERATIVE } = options;
+            const { iterationType = types_1.IterationType.ITERATIVE } = options;
             this._loopType = iterationType;
         }
     }
-    /**
-     * Creates a new instance of BinaryTreeNode with the given key and value.
-     * @param {BinaryTreeNodeKey} key - The key for the new node.
-     * @param {N['val']} val - The value for the new node.
-     * @returns {N} - The newly created BinaryTreeNode.
-     */
-    createNode(key, val) {
-        return new BinaryTreeNode(key, val);
-    }
+    _root = null;
     /**
      * Get the root node of the binary tree.
      */
     get root() {
         return this._root;
     }
+    _size = 0;
     /**
      * Get the number of nodes in the binary tree.
      */
@@ -146,21 +154,13 @@ export class BinaryTree {
         this._loopType = v;
     }
     /**
-     * Swap the data of two nodes in the binary tree.
-     * @param {N} srcNode - The source node to swap.
-     * @param {N} destNode - The destination node to swap.
-     * @returns {N} - The destination node after the swap.
+     * Creates a new instance of BinaryTreeNode with the given key and value.
+     * @param {BinaryTreeNodeKey} key - The key for the new node.
+     * @param {N['val']} val - The value for the new node.
+     * @returns {N} - The newly created BinaryTreeNode.
      */
-    _swap(srcNode, destNode) {
-        const { key, val } = destNode;
-        const tempNode = this.createNode(key, val);
-        if (tempNode) {
-            destNode.key = srcNode.key;
-            destNode.val = srcNode.val;
-            srcNode.key = tempNode.key;
-            srcNode.val = tempNode.val;
-        }
-        return destNode;
+    createNode(key, val) {
+        return new BinaryTreeNode(key, val);
     }
     /**
      * Clear the binary tree, removing all nodes.
@@ -184,7 +184,7 @@ export class BinaryTree {
      */
     add(keyOrNode, val) {
         const _bfs = (root, newNode) => {
-            const queue = new Queue([root]);
+            const queue = new queue_1.Queue([root]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
@@ -261,7 +261,7 @@ export class BinaryTree {
                 inserted.push(this.add(null));
                 continue;
             }
-            const val = values === null || values === void 0 ? void 0 : values[i];
+            const val = values?.[i];
             inserted.push(this.add(keyOrNode, val));
         }
         return inserted;
@@ -294,7 +294,7 @@ export class BinaryTree {
         const curr = typeof nodeOrKey === 'number' ? this.get(nodeOrKey) : nodeOrKey;
         if (!curr)
             return bstDeletedResult;
-        const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
+        const parent = curr?.parent ? curr.parent : null;
         let needBalanced = null, orgCurrent = curr;
         if (!curr.left) {
             if (!parent) {
@@ -303,10 +303,10 @@ export class BinaryTree {
             }
             else {
                 const { familyPosition: fp } = curr;
-                if (fp === FamilyPosition.LEFT || fp === FamilyPosition.ROOT_LEFT) {
+                if (fp === types_1.FamilyPosition.LEFT || fp === types_1.FamilyPosition.ROOT_LEFT) {
                     parent.left = curr.right;
                 }
-                else if (fp === FamilyPosition.RIGHT || fp === FamilyPosition.ROOT_RIGHT) {
+                else if (fp === types_1.FamilyPosition.RIGHT || fp === types_1.FamilyPosition.ROOT_RIGHT) {
                     parent.right = curr.right;
                 }
                 needBalanced = parent;
@@ -348,7 +348,7 @@ export class BinaryTree {
         if (typeof beginRoot === 'number')
             beginRoot = this.get(beginRoot);
         let depth = 0;
-        while (distNode === null || distNode === void 0 ? void 0 : distNode.parent) {
+        while (distNode?.parent) {
             if (distNode === beginRoot) {
                 return depth;
             }
@@ -374,7 +374,7 @@ export class BinaryTree {
             beginRoot = this.get(beginRoot);
         if (!beginRoot)
             return -1;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _getMaxHeight = (cur) => {
                 if (!cur)
                     return -1;
@@ -414,10 +414,9 @@ export class BinaryTree {
      * @returns The function `getMinHeight` returns the minimum height of a binary tree.
      */
     getMinHeight(beginRoot = this.root, iterationType = this.iterationType) {
-        var _a, _b, _c;
         if (!beginRoot)
             return -1;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _getMinHeight = (cur) => {
                 if (!cur)
                     return 0;
@@ -443,8 +442,8 @@ export class BinaryTree {
                     if (!node.right || last === node.right) {
                         node = stack.pop();
                         if (node) {
-                            const leftMinHeight = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
-                            const rightMinHeight = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
+                            const leftMinHeight = node.left ? depths.get(node.left) ?? -1 : -1;
+                            const rightMinHeight = node.right ? depths.get(node.right) ?? -1 : -1;
                             depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
                             last = node;
                             node = null;
@@ -454,7 +453,7 @@ export class BinaryTree {
                         node = node.right;
                 }
             }
-            return (_c = depths.get(beginRoot)) !== null && _c !== void 0 ? _c : -1;
+            return depths.get(beginRoot) ?? -1;
         }
     }
     /**
@@ -492,7 +491,7 @@ export class BinaryTree {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 if (callback(cur) === nodeProperty) {
                     ans.push(cur);
@@ -507,7 +506,7 @@ export class BinaryTree {
             _traverse(beginRoot);
         }
         else {
-            const queue = new Queue([beginRoot]);
+            const queue = new queue_1.Queue([beginRoot]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
@@ -560,9 +559,8 @@ export class BinaryTree {
      * @returns either the found node (of type N) or null if no node is found.
      */
     get(nodeProperty, callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
-        var _a;
         // TODO may support finding node by value equal
-        return (_a = this.getNodes(nodeProperty, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
+        return this.getNodes(nodeProperty, callback, true, beginRoot, iterationType)[0] ?? null;
     }
     /**
      * The function `getPathToRoot` returns an array of nodes starting from a given node and traversing
@@ -602,7 +600,7 @@ export class BinaryTree {
             beginRoot = this.get(beginRoot);
         if (!beginRoot)
             return beginRoot;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 if (!cur.left)
                     return cur;
@@ -612,7 +610,7 @@ export class BinaryTree {
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            const _traverse = trampoline((cur) => {
+            const _traverse = (0, utils_1.trampoline)((cur) => {
                 if (!cur.left)
                     return cur;
                 return _traverse.cont(cur.left);
@@ -635,7 +633,7 @@ export class BinaryTree {
         // TODO support get right most by passing key in
         if (!beginRoot)
             return beginRoot;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 if (!cur.right)
                     return cur;
@@ -645,7 +643,7 @@ export class BinaryTree {
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            const _traverse = trampoline((cur) => {
+            const _traverse = (0, utils_1.trampoline)((cur) => {
                 if (!cur.right)
                     return cur;
                 return _traverse.cont(cur.right);
@@ -666,7 +664,7 @@ export class BinaryTree {
         // TODO there is a bug
         if (!beginRoot)
             return true;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const dfs = (cur, min, max) => {
                 if (!cur)
                     return true;
@@ -726,7 +724,7 @@ export class BinaryTree {
         const ans = [];
         if (!beginRoot)
             return ans;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 ans.push(callback(cur));
                 cur.left && _traverse(cur.left);
@@ -760,11 +758,11 @@ export class BinaryTree {
      * iteration used in the depth-first search algorithm. It can have two possible values:
      * @returns The function `dfs` returns an array of `MapCallbackReturn<N>` values.
      */
-    dfs(callback = this._defaultCallbackByKey, pattern = 'in', beginRoot = this.root, iterationType = IterationType.ITERATIVE) {
+    dfs(callback = this._defaultCallbackByKey, pattern = 'in', beginRoot = this.root, iterationType = types_1.IterationType.ITERATIVE) {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (node) => {
                 switch (pattern) {
                     case 'in':
@@ -830,7 +828,6 @@ export class BinaryTree {
         }
         return ans;
     }
-    // --- start additional methods ---
     /**
      * The bfs function performs a breadth-first search traversal on a binary tree, executing a callback
      * function on each node.
@@ -852,7 +849,7 @@ export class BinaryTree {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _recursive = (node, level) => {
                 callback && ans.push(callback(node, withLevel ? level : undefined));
                 if (node.left)
@@ -895,13 +892,7 @@ export class BinaryTree {
             return node;
         }
     }
-    /**
-     * Time complexity is O(n)
-     * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
-     * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
-     * the tree's structure should be restored to its original state to maintain the tree's integrity.
-     * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
-     */
+    // --- start additional methods ---
     /**
      * The `morris` function performs a depth-first traversal of a binary tree using the Morris traversal
      * algorithm and returns an array of values obtained by applying a callback function to each node.
@@ -1000,6 +991,31 @@ export class BinaryTree {
         }
         return ans;
     }
+    /**
+     * Swap the data of two nodes in the binary tree.
+     * @param {N} srcNode - The source node to swap.
+     * @param {N} destNode - The destination node to swap.
+     * @returns {N} - The destination node after the swap.
+     */
+    _swap(srcNode, destNode) {
+        const { key, val } = destNode;
+        const tempNode = this.createNode(key, val);
+        if (tempNode) {
+            destNode.key = srcNode.key;
+            destNode.val = srcNode.val;
+            srcNode.key = tempNode.key;
+            srcNode.val = tempNode.val;
+        }
+        return destNode;
+    }
+    /**
+     * Time complexity is O(n)
+     * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
+     * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
+     * the tree's structure should be restored to its original state to maintain the tree's integrity.
+     * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
+     */
+    _defaultCallbackByKey = node => node.key;
     /**
      * The function `_addTo` adds a new node to a binary tree if there is an available position.
      * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to
@@ -1058,3 +1074,4 @@ export class BinaryTree {
         this._size = v;
     }
 }
+exports.BinaryTree = BinaryTree;