data-structure-typed 1.38.1 → 1.38.3

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BFSCallback, BFSCallbackReturn, BinaryTreeNodeKey, BinaryTreeNodeNested, BinaryTreeOptions, MapCallback, MapCallbackReturn } from '../../types';
+import type { BFSCallback, BinaryTreeNodeKey, BinaryTreeNodeNested, BinaryTreeOptions, MapCallback } from '../../types';
 import { BinaryTreeDeletedResult, DFSOrderPattern, FamilyPosition, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 /**
@@ -207,7 +207,7 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * traverse the binary tree. It can have two possible values:
      * @returns The function `getNodes` returns an array of nodes (`N[]`).
      */
-    getNodes(nodeProperty: BinaryTreeNodeKey | N, callback?: MapCallback<N>, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
+    getNodes<C extends MapCallback<N> = MapCallback<N, BinaryTreeNodeKey>>(nodeProperty: BinaryTreeNodeKey | N, callback?: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
     /**
      * The function checks if a binary tree has a node with a given property or key.
      * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter is the key or value of
@@ -225,7 +225,7 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * performed when searching for nodes in the binary tree. It can have one of the following values:
      * @returns a boolean value.
      */
-    has(nodeProperty: BinaryTreeNodeKey | N, callback?: MapCallback<N>, beginRoot?: N | null, iterationType?: IterationType): boolean;
+    has<C extends MapCallback<N> = MapCallback<N, BinaryTreeNodeKey>>(nodeProperty: BinaryTreeNodeKey | N, callback?: C, beginRoot?: N | null, iterationType?: IterationType): boolean;
     /**
      * The function `get` returns the first node in a binary tree that matches the given property or key.
      * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter is the key or value of
@@ -241,7 +241,7 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * 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(nodeProperty: BinaryTreeNodeKey | N, callback?: MapCallback<N>, beginRoot?: N | null, iterationType?: IterationType): N | null;
+    get<C extends MapCallback<N> = MapCallback<N, BinaryTreeNodeKey>>(nodeProperty: BinaryTreeNodeKey | N, callback?: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
     /**
      * 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.
@@ -310,7 +310,7 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * performed on the binary tree. It can have two possible values:
      * @returns The function `subTreeTraverse` returns an array of `MapCallbackReturn<N>`.
      */
-    subTreeTraverse(callback?: MapCallback<N>, beginRoot?: N | BinaryTreeNodeKey | null, iterationType?: IterationType): MapCallbackReturn<N>[];
+    subTreeTraverse<C extends MapCallback<N> = MapCallback<N, BinaryTreeNodeKey>>(callback?: C, beginRoot?: N | BinaryTreeNodeKey | null, iterationType?: IterationType): ReturnType<C>[];
     /**
      * The `dfs` function performs a depth-first search traversal on a binary tree, executing a callback
      * function on each node according to a specified order pattern.
@@ -326,7 +326,7 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * 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?: MapCallback<N>, pattern?: DFSOrderPattern, beginRoot?: N | null, iterationType?: IterationType): MapCallbackReturn<N>[];
+    dfs<C extends MapCallback<N> = MapCallback<N, BinaryTreeNodeKey>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null, iterationType?: IterationType): ReturnType<C>[];
     /**
      * The bfs function performs a breadth-first search traversal on a binary tree, executing a callback
      * function on each node.
@@ -344,7 +344,7 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * in the breadth-first search (BFS) algorithm. It can have two possible values:
      * @returns The function `bfs` returns an array of `BFSCallbackReturn<N>[]`.
      */
-    bfs(callback?: BFSCallback<N>, withLevel?: boolean, beginRoot?: N | null, iterationType?: IterationType): BFSCallbackReturn<N>[];
+    bfs<C extends BFSCallback<N> = BFSCallback<N, BinaryTreeNodeKey>>(callback?: C, withLevel?: boolean, beginRoot?: N | null, iterationType?: IterationType): ReturnType<C>[];
     /**
      * The function returns the predecessor node of a given node in a binary tree.
      * @param {N} node - The parameter "node" represents a node in a binary tree.
@@ -365,7 +365,7 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * `beginRoot` is `null`, an empty array will be returned.
      * @returns The `morris` function returns an array of `MapCallbackReturn<N>` values.
      */
-    morris(callback?: MapCallback<N>, pattern?: DFSOrderPattern, beginRoot?: N | null): MapCallbackReturn<N>[];
+    morris<C extends MapCallback<N> = MapCallback<N, BinaryTreeNodeKey>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null): ReturnType<C>[];
     /**
      * Swap the data of two nodes in the binary tree.
      * @param {N} srcNode - The source node to swap.
@@ -380,7 +380,7 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * 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.
      */
-    protected _defaultCallbackByKey: MapCallback<N>;
+    protected _defaultCallbackByKey: (node: N) => number;
     /**
      * 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

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,66 +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._loopType = IterationType.ITERATIVE;
-        this._root = null;
-        this._size = 0;
-        /**
-         * 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.
-         */
-        this._defaultCallbackByKey = node => node.key;
         if (options !== undefined) {
-            const { iterationType = IterationType.ITERATIVE } = options;
+            const { iterationType = types_1.IterationType.ITERATIVE } = options;
             this._loopType = iterationType;
         }
     }
+    _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.
      */
@@ -174,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) {
@@ -251,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;
@@ -284,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) {
@@ -293,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;
@@ -338,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;
             }
@@ -364,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;
@@ -404,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;
@@ -433,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;
@@ -444,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;
         }
     }
     /**
@@ -482,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);
@@ -497,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) {
@@ -550,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
@@ -592,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;
@@ -602,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);
@@ -625,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;
@@ -635,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);
@@ -656,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;
@@ -716,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);
@@ -750,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':
@@ -841,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)
@@ -1000,6 +1008,14 @@ export class BinaryTree {
         }
         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;

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeNodeKey, BSTComparator, BSTNodeNested, BSTOptions, MapCallback, MapCallbackReturn } from '../../types';
+import type { BinaryTreeNodeKey, BSTComparator, BSTNodeNested, BSTOptions, MapCallback } from '../../types';
 import { CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
@@ -72,7 +72,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
      * @returns either the first node that matches the given nodeProperty and callback, or null if no
      * matching node is found.
      */
-    get(nodeProperty: BinaryTreeNodeKey | N, callback?: MapCallback<N>, beginRoot?: N | null, iterationType?: IterationType): N | null;
+    get<C extends MapCallback<N> = MapCallback<N, BinaryTreeNodeKey>>(nodeProperty: BinaryTreeNodeKey | N, 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
@@ -110,7 +110,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
      * traverse the binary tree. It can have one of the following values:
      * @returns an array of nodes (N[]).
      */
-    getNodes(nodeProperty: BinaryTreeNodeKey | N, callback?: MapCallback<N>, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
+    getNodes<C extends MapCallback<N> = MapCallback<N, BinaryTreeNodeKey>>(nodeProperty: BinaryTreeNodeKey | N, callback?: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
     /**
      * The `lesserOrGreaterTraverse` function traverses a binary tree and applies a callback function to
      * nodes that have a key value lesser or greater than a target key value.
@@ -128,7 +128,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
      * done recursively or iteratively. It can have two possible values:
      * @returns The function `lesserOrGreaterTraverse` returns an array of `MapCallbackReturn<N>`.
      */
-    lesserOrGreaterTraverse(callback?: MapCallback<N>, lesserOrGreater?: CP, targetNode?: N | BinaryTreeNodeKey | null, iterationType?: IterationType): MapCallbackReturn<N>;
+    lesserOrGreaterTraverse<C extends MapCallback<N> = MapCallback<N, BinaryTreeNodeKey>>(callback?: C, lesserOrGreater?: CP, targetNode?: N | BinaryTreeNodeKey | null, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Balancing Adjustment:
      * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.