data-structure-typed 1.37.2 → 1.37.3

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

@@ -1,4 +1,4 @@
-import { CP, LoopType } from '../../types';
+import { CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { Queue } from '../queue';
 export class BSTNode extends BinaryTreeNode {
@@ -124,9 +124,10 @@ export class BST extends BinaryTree {
      * to the binary search tree.
      * @param {N['val'][]} data - The values of tree nodes
      * @param {boolean} isBalanceAdd - If true the nodes will be balance inserted in binary search method.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies whether to use a
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(keysOrNodes, data, isBalanceAdd = true) {
+    addMany(keysOrNodes, data, isBalanceAdd = true, iterationType = this.iterationType) {
         // TODO this addMany function is inefficient, it should be optimized
         function hasNoNull(arr) {
             return arr.indexOf(null) === -1;
@@ -187,7 +188,7 @@ export class BST extends BinaryTree {
                 }
             }
         };
-        if (this.loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             recursive(sortedKeysOrNodes, sortedData);
         }
         else {
@@ -208,20 +209,19 @@ export class BST extends BinaryTree {
         return (_a = this.getNodes(nodeProperty, callback, true)[0]) !== null && _a !== void 0 ? _a : null;
     }
     /**
-     * The function returns the key of the rightmost node if the comparison between two values is less than, the key of the
-     * leftmost node if the comparison is greater than, and the key of the rightmost node otherwise.
-     * @returns The method `lastKey()` returns the key of the rightmost node in the binary tree if the comparison between
-     * the values at index 0 and 1 is less than, otherwise it returns the key of the leftmost node. If the comparison is
-     * equal, it returns the key of the rightmost node. If there are no nodes in the tree, it returns 0.
+     * lastKey returns the last key in a binary tree. If the binary tree is empty, it returns 0.
+     * @param beginRoot - The `beginRoot` parameter is an optional parameter that specifies the root node from which to begin
+     * the search for the last key.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies whether to use a recursive or iterative approach to search for the last key.
      */
-    lastKey() {
+    lastKey(beginRoot = this.root, iterationType = this.iterationType) {
         var _a, _b, _c, _d, _e, _f;
         if (this._compare(0, 1) === CP.lt)
-            return (_b = (_a = this.getRightMost()) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : 0;
+            return (_b = (_a = this.getRightMost(beginRoot, iterationType)) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : 0;
         else if (this._compare(0, 1) === CP.gt)
-            return (_d = (_c = this.getLeftMost()) === null || _c === void 0 ? void 0 : _c.key) !== null && _d !== void 0 ? _d : 0;
+            return (_d = (_c = this.getLeftMost(beginRoot, iterationType)) === null || _c === void 0 ? void 0 : _c.key) !== null && _d !== void 0 ? _d : 0;
         else
-            return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.key) !== null && _f !== void 0 ? _f : 0;
+            return (_f = (_e = this.getRightMost(beginRoot, iterationType)) === null || _e === void 0 ? void 0 : _e.key) !== null && _f !== void 0 ? _f : 0;
     }
     /**
      * The function `getNodes` returns an array of nodes in a binary tree that match a given property value.
@@ -233,13 +233,14 @@ export class BST extends BinaryTree {
      * return only one node that matches the given `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne`
      * is set to `true`, the function will return an array with only one node (if
      * @param beginRoot - The `beginRoot` parameter is an optional parameter that specifies the root node from which to
+     * @param iterationType
      * @returns an array of nodes (type N).
      */
-    getNodes(nodeProperty, callback = this._defaultCallbackByKey, onlyOne = false, beginRoot = this.root) {
+    getNodes(nodeProperty, callback = this._defaultCallbackByKey, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (this.loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 const callbackResult = callback(cur);
                 if (callbackResult === nodeProperty) {
@@ -295,45 +296,46 @@ export class BST extends BinaryTree {
      * The `lesserOrGreaterTraverse` function adds a delta value to the specified property of all nodes in a binary tree that
      * have a greater value than a given node.
      * @param callback - The `callback` parameter is a function that takes a node as a parameter and returns a value.
-     * @param {N | BinaryTreeNodeKey | null} node - The `node` parameter can be either of type `N` (a generic type), `BinaryTreeNodeKey`, or `null`. It
      * represents the node in the binary tree to which the delta value will be added.
      * @param lesserOrGreater - The `lesserOrGreater` parameter is an optional parameter that specifies whether the delta
+     * @param targetNode - The `targetNode` parameter is an optional parameter that specifies the node in the binary tree
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies whether to use a
      */
-    lesserOrGreaterTraverse(callback = this._defaultCallbackByKey, lesserOrGreater = CP.lt, node) {
-        if (typeof node === 'number')
-            node = this.get(node);
+    lesserOrGreaterTraverse(callback = this._defaultCallbackByKey, lesserOrGreater = CP.lt, targetNode = this.root, iterationType = this.iterationType) {
+        if (typeof targetNode === 'number')
+            targetNode = this.get(targetNode);
         const ans = [];
-        if (!node)
-            return [];
-        const key = node.key;
+        if (!targetNode)
+            return ans;
+        const targetKey = targetNode.key;
         if (!this.root)
-            return false;
-        if (this.loopType === LoopType.RECURSIVE) {
+            return ans;
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
-                const compared = this._compare(cur.key, key);
+                const compared = this._compare(cur.key, targetKey);
                 if (compared === lesserOrGreater)
                     ans.push(callback(cur));
                 if (!cur.left && !cur.right)
                     return;
-                if (cur.left && this._compare(cur.left.key, key) === lesserOrGreater)
+                if (cur.left && this._compare(cur.left.key, targetKey) === lesserOrGreater)
                     _traverse(cur.left);
-                if (cur.right && this._compare(cur.right.key, key) === lesserOrGreater)
+                if (cur.right && this._compare(cur.right.key, targetKey) === lesserOrGreater)
                     _traverse(cur.right);
             };
             _traverse(this.root);
-            return true;
+            return ans;
         }
         else {
             const queue = new Queue([this.root]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
-                    const compared = this._compare(cur.key, key);
+                    const compared = this._compare(cur.key, targetKey);
                     if (compared === lesserOrGreater)
                         ans.push(callback(cur));
-                    if (cur.left && this._compare(cur.left.key, key) === lesserOrGreater)
+                    if (cur.left && this._compare(cur.left.key, targetKey) === lesserOrGreater)
                         queue.push(cur.left);
-                    if (cur.right && this._compare(cur.right.key, key) === lesserOrGreater)
+                    if (cur.right && this._compare(cur.right.key, targetKey) === lesserOrGreater)
                         queue.push(cur.right);
                 }
             }
@@ -354,12 +356,12 @@ export class BST extends BinaryTree {
      * constructs a balanced binary search tree using either a recursive or iterative approach.
      * @returns The function `perfectlyBalance()` returns a boolean value.
      */
-    perfectlyBalance() {
+    perfectlyBalance(iterationType = this.iterationType) {
         const sorted = this.dfs(node => node, 'in'), n = sorted.length;
         this.clear();
         if (sorted.length < 1)
             return false;
-        if (this.loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
@@ -394,12 +396,12 @@ export class BST extends BinaryTree {
      * The function `isAVLBalanced` checks if a binary tree is balanced according to the AVL tree property.
      * @returns a boolean value.
      */
-    isAVLBalanced() {
+    isAVLBalanced(iterationType = this.iterationType) {
         var _a, _b;
         if (!this.root)
             return true;
         let balanced = true;
-        if (this.loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _height = (cur) => {
                 if (!cur)
                     return 0;

package/lib/data-structures/binary-tree/tree-multiset.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BinaryTreeNodeKey, TreeMultisetNodeNested, TreeMultisetOptions } from '../../types';
-import { BinaryTreeDeletedResult } from '../../types';
+import { BinaryTreeDeletedResult, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultisetNode<V = any, FAMILY extends TreeMultisetNode<V, FAMILY> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, FAMILY> {
@@ -91,7 +91,7 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      * constructs a balanced binary search tree using either a recursive or iterative approach.
      * @returns The function `perfectlyBalance()` returns a boolean value.
      */
-    perfectlyBalance(): boolean;
+    perfectlyBalance(iterationType?: IterationType): boolean;
     /**
      * The `delete` function removes a node from a binary search tree and returns the deleted node along with the parent
      * node that needs to be balanced.

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

@@ -1,4 +1,4 @@
-import { CP, FamilyPosition, LoopType } from '../../types';
+import { CP, FamilyPosition, IterationType } from '../../types';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export class TreeMultisetNode extends AVLTreeNode {
     /**
@@ -220,12 +220,12 @@ export class TreeMultiset extends AVLTree {
      * constructs a balanced binary search tree using either a recursive or iterative approach.
      * @returns The function `perfectlyBalance()` returns a boolean value.
      */
-    perfectlyBalance() {
+    perfectlyBalance(iterationType = this.iterationType) {
         const sorted = this.dfs(node => node, 'in'), n = sorted.length;
         if (sorted.length < 1)
             return false;
         this.clear();
-        if (this.loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;

package/lib/types/data-structures/binary-tree.d.ts

@@ -5,7 +5,7 @@ import { BinaryTreeNode } from '../../data-structures/binary-tree';
  * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
  * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
  */
-export declare enum LoopType {
+export declare enum IterationType {
     ITERATIVE = "ITERATIVE",
     RECURSIVE = "RECURSIVE"
 }
@@ -31,5 +31,5 @@ export type BinaryTreeDeletedResult<N> = {
 export type BinaryTreeNodeProperties<N extends BinaryTreeNode<N['val'], N>> = BinaryTreeNodeProperty<N>[];
 export type BinaryTreeNodeNested<T> = BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BinaryTreeOptions = {
-    loopType?: LoopType;
+    iterationType?: IterationType;
 };

package/lib/types/data-structures/binary-tree.js

@@ -4,11 +4,11 @@
  * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
  * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
  */
-export var LoopType;
-(function (LoopType) {
-    LoopType["ITERATIVE"] = "ITERATIVE";
-    LoopType["RECURSIVE"] = "RECURSIVE";
-})(LoopType || (LoopType = {}));
+export var IterationType;
+(function (IterationType) {
+    IterationType["ITERATIVE"] = "ITERATIVE";
+    IterationType["RECURSIVE"] = "RECURSIVE";
+})(IterationType || (IterationType = {}));
 export var FamilyPosition;
 (function (FamilyPosition) {
     FamilyPosition["ROOT"] = "ROOT";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.37.2",
+  "version": "1.37.3",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/index.js",
   "module": "lib/index.js",
@@ -28,7 +28,7 @@
     "fix:test": "npm run lint:test && npm run format:test",
     "fix": "npm run fix:src && npm run fix:test",
     "update:individuals": "npm i avl-tree-typed binary-tree-typed bst-typed heap-typed --save-dev",
-    "install:individuals": "npm i avl-tree-typed binary-tree-typed bst-typed deque-typed directed-graph-typed doubly-linked-list-typed graph-typed heap-typed linked-list-typed max-heap-typed max-priority-queue-typed min-heap-typed min-priority-queue-typed priority-queue-typed singly-linked-list-typed stack-typed tree-multiset-typed trie-typed undirected-graph-typed queue-typed --save-dev",
+    "install:all-individuals": "npm i avl-tree-typed binary-tree-typed bst-typed deque-typed directed-graph-typed doubly-linked-list-typed graph-typed heap-typed linked-list-typed max-heap-typed max-priority-queue-typed min-heap-typed min-priority-queue-typed priority-queue-typed singly-linked-list-typed stack-typed tree-multiset-typed trie-typed undirected-graph-typed queue-typed --save-dev",
     "test": "jest",
     "check:deps": "dependency-cruiser src",
     "changelog": "auto-changelog",
@@ -58,17 +58,17 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.37.0",
+    "avl-tree-typed": "^1.37.2",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.37.0",
-    "bst-typed": "^1.37.0",
+    "binary-tree-typed": "^1.37.2",
+    "bst-typed": "^1.37.2",
     "dependency-cruiser": "^14.1.0",
     "eslint": "^8.50.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-import-resolver-alias": "^1.1.2",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
-    "heap-typed": "^1.37.0",
+    "heap-typed": "^1.37.2",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",

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

@@ -72,27 +72,25 @@ export class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends B
 
   /**
    * The function overrides the add method of a binary tree node and balances the tree after inserting a new node.
-   * @param {BinaryTreeNodeKey} key - The `key` parameter is the identifier of the binary tree node that we want to add.
+   * @param keyOrNode - The `keyOrNode` parameter is either a key or a node that needs to be added to the binary tree.
    * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. It is of type
    * `N['val']`, which means it should be of the same type as the `val` property of the nodes in the binary tree.
    * @returns The method is returning the inserted node, or null or undefined if the insertion was not successful.
    */
-  override add(key: BinaryTreeNodeKey, val?: N['val']): N | null | undefined {
+  override add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined {
     // TODO support node as a param
-    const inserted = super.add(key, val);
+    const inserted = super.add(keyOrNode, val);
     if (inserted) this._balancePath(inserted);
     return inserted;
   }
 
   /**
-   * The function overrides the delete method of a binary tree and performs additional operations to balance the tree after
-   * deletion.
-   * @param {BinaryTreeNodeKey} key - The `key` parameter represents the identifier of the binary tree node that needs to be
-   * removed.
+   * The function overrides the delete method of a binary tree and performs additional operations to balance the tree after deletion.
    * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
+   * @param nodeOrKey - The `nodeOrKey` parameter is either a node or a key that needs to be deleted from the binary tree.
    */
-  override delete(key: BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[] {
-    const deletedResults = super.delete(key);
+  override delete(nodeOrKey: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[] {
+    const deletedResults = super.delete(nodeOrKey);
     for (const {needBalanced} of deletedResults) {
       if (needBalanced) {
         this._balancePath(needBalanced);