data-structure-typed 1.36.8 → 1.37.0

package/dist/data-structures/linked-list/skip-linked-list.d.ts

@@ -52,10 +52,10 @@ export declare class SkipList<K, V> {
      */
     get(key: K): V | undefined;
     /**
-     * The `remove` function removes a node with a specific key from a Skip List data structure.
+     * The `delete` function removes a node with a specific key from a Skip List data structure.
      * @param {K} key - The key parameter represents the key of the node that needs to be removed from the skip list.
-     * @returns The `remove` method returns a boolean value. It returns `true` if the key was successfully removed from the
+     * @returns The `delete` method returns a boolean value. It returns `true` if the key was successfully removed from the
      * skip list, and `false` if the key was not found in the skip list.
      */
-    remove(key: K): boolean;
+    delete(key: K): boolean;
 }

package/dist/data-structures/linked-list/skip-linked-list.js

@@ -109,12 +109,12 @@ class SkipList {
         return undefined;
     }
     /**
-     * The `remove` function removes a node with a specific key from a Skip List data structure.
+     * The `delete` function removes a node with a specific key from a Skip List data structure.
      * @param {K} key - The key parameter represents the key of the node that needs to be removed from the skip list.
-     * @returns The `remove` method returns a boolean value. It returns `true` if the key was successfully removed from the
+     * @returns The `delete` method returns a boolean value. It returns `true` if the key was successfully removed from the
      * skip list, and `false` if the key was not found in the skip list.
      */
-    remove(key) {
+    delete(key) {
         const update = new Array(this.maxLevel).fill(this.head);
         let current = this.head;
         for (let i = this.level - 1; i >= 0; i--) {

package/dist/data-structures/queue/deque.d.ts

@@ -150,12 +150,12 @@ export declare class ArrayDeque<E> {
      */
     insert(index: number, value: E): E[];
     /**
-     * The remove function removes an element from an array at a specified index.
+     * The delete function removes an element from an array at a specified index.
      * @param {number} index - The index parameter specifies the position of the element to be removed from the array. It
      * is a number that represents the index of the element to be removed.
      * @returns The method is returning an array containing the removed element.
      */
-    remove(index: number): E[];
+    delete(index: number): E[];
     /**
      * The function checks if an array called "_nodes" is empty.
      * @returns The method `isEmpty()` is returning a boolean value. It returns `true` if the length of the `_nodes` array

package/dist/data-structures/queue/deque.js

@@ -256,12 +256,12 @@ class ArrayDeque {
         return this._nodes.splice(index, 0, value);
     }
     /**
-     * The remove function removes an element from an array at a specified index.
+     * The delete function removes an element from an array at a specified index.
      * @param {number} index - The index parameter specifies the position of the element to be removed from the array. It
      * is a number that represents the index of the element to be removed.
      * @returns The method is returning an array containing the removed element.
      */
-    remove(index) {
+    delete(index) {
         return this._nodes.splice(index, 1);
     }
     /**

package/dist/data-structures/queue/queue.js

@@ -94,7 +94,7 @@ class Queue {
         this.offset += 1;
         if (this.offset * 2 < this.nodes.length)
             return first;
-        // only remove dequeued elements when reaching half size
+        // only delete dequeued elements when reaching half size
         // to decrease latency of shifting elements.
         this.nodes = this.nodes.slice(this.offset);
         this.offset = 0;

package/dist/data-structures/trie/trie.d.ts

@@ -45,10 +45,10 @@ export declare class Trie {
     private _caseProcess;
     /**
      * Remove a word from the Trie structure.
-     * @param{string} word - The word to remove.
+     * @param{string} word - The word to delete.
      * @returns {boolean} True if the word was successfully removed.
      */
-    remove(word: string): boolean;
+    delete(word: string): boolean;
     getHeight(): number;
     /**
      * Check if a given input string has an absolute prefix in the Trie, meaning it's not a complete word.

package/dist/data-structures/trie/trie.js

@@ -100,10 +100,10 @@ class Trie {
     }
     /**
      * Remove a word from the Trie structure.
-     * @param{string} word - The word to remove.
+     * @param{string} word - The word to delete.
      * @returns {boolean} True if the word was successfully removed.
      */
-    remove(word) {
+    delete(word) {
         word = this._caseProcess(word);
         let isDeleted = false;
         const dfs = (cur, i) => {

package/dist/interfaces/binary-tree.d.ts

@@ -3,5 +3,5 @@ import { BinaryTreeDeletedResult, BinaryTreeNodeKey } from '../types';
 export interface IBinaryTree<N extends BinaryTreeNode<N['val'], N>> {
     createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
     add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined;
-    remove(nodeOrKey: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
+    delete(nodeOrKey: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
 }

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

@@ -21,13 +21,13 @@ export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> e
      */
     constructor(options?: AVLTreeOptions);
     /**
-     * The `swapLocation` function swaps the location of two nodes in a binary tree.
-     * @param {N} srcNode - The source node that you want to swap with the destination node.
+     * The `_swap` function swaps the location of two nodes in a binary tree.
+     * @param {N} srcNode - The source node that you want to _swap with the destination node.
      * @param {N} destNode - The `destNode` parameter represents the destination node where the values from `srcNode` will
      * be swapped to.
      * @returns The `destNode` is being returned.
      */
-    swapLocation(srcNode: N, destNode: N): N;
+    protected _swap(srcNode: N, destNode: N): N;
     /**
      * The function creates a new AVL tree node with the given key and value.
      * @param {BinaryTreeNodeKey} key - The `key` parameter is the identifier for the binary tree node. It is used to uniquely
@@ -46,13 +46,13 @@ export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> e
      */
     add(key: BinaryTreeNodeKey, val?: N['val']): N | null | undefined;
     /**
-     * The function overrides the remove method of a binary tree and performs additional operations to balance the tree after
+     * 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.
      * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    remove(key: BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
+    delete(key: BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
     /**
      * The balance factor of a given AVL tree node is calculated by subtracting the height of its left subtree from the
      * height of its right subtree.

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

@@ -23,13 +23,13 @@ export class AVLTree extends BST {
         super(options);
     }
     /**
-     * The `swapLocation` function swaps the location of two nodes in a binary tree.
-     * @param {N} srcNode - The source node that you want to swap with the destination node.
+     * The `_swap` function swaps the location of two nodes in a binary tree.
+     * @param {N} srcNode - The source node that you want to _swap with the destination node.
      * @param {N} destNode - The `destNode` parameter represents the destination node where the values from `srcNode` will
      * be swapped to.
      * @returns The `destNode` is being returned.
      */
-    swapLocation(srcNode, destNode) {
+    _swap(srcNode, destNode) {
         const { key, val, height } = destNode;
         const tempNode = this.createNode(key, val);
         if (tempNode) {
@@ -69,14 +69,14 @@ export class AVLTree extends BST {
         return inserted;
     }
     /**
-     * The function overrides the remove method of a binary tree and performs additional operations to balance the tree after
+     * 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.
      * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    remove(key) {
-        const deletedResults = super.remove(key);
+    delete(key) {
+        const deletedResults = super.delete(key);
         for (const { needBalanced } of deletedResults) {
             if (needBalanced) {
                 this._balancePath(needBalanced);

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

@@ -55,17 +55,18 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
     get size(): number;
     private _loopType;
     get loopType(): LoopType;
+    set loopType(v: LoopType);
     visitedKey: BinaryTreeNodeKey[];
     visitedVal: N['val'][];
     visitedNode: N[];
     /**
-     * The `swapLocation` function swaps the location of two nodes in a binary tree.
-     * @param {N} srcNode - The source node that you want to swap with the destination node.
+     * The `_swap` function swaps the location of two nodes in a binary tree.
+     * @param {N} srcNode - The source node that you want to _swap with the destination node.
      * @param {N} destNode - The `destNode` parameter represents the destination node where the values from `srcNode` will
      * be swapped to.
      * @returns The `destNode` is being returned.
      */
-    swapLocation(srcNode: N, destNode: N): N;
+    protected _swap(srcNode: N, destNode: N): N;
     /**
      * The clear() function resets the root, size, and maxKey properties to their initial values.
      */
@@ -111,13 +112,13 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      */
     refill(keysOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[], data?: N[] | Array<N['val']>): boolean;
     /**
-     * The `remove` function in TypeScript is used to delete a node from a binary search tree and returns an array of objects
+     * The `delete` function in TypeScript is used to delete a node from a binary search tree and returns an array of objects
      * containing the deleted node and the node that needs to be balanced.
      * @param {N | BinaryTreeNodeKey} nodeOrKey - The `nodeOrKey` parameter can be either a node object (`N`) or a binary tree
      * node ID (`BinaryTreeNodeKey`).
-     * @returns The function `remove` returns an array of `BinaryTreeDeletedResult<N>` objects.
+     * @returns The function `delete` returns an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    remove(nodeOrKey: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
+    delete(nodeOrKey: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
     /**
      * The function calculates the depth of a node in a binary tree.
      * @param {N | BinaryTreeNodeKey | null} distNode - The `distNode` parameter can be any node of the tree
@@ -236,10 +237,10 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
     getRightMost(beginRoot: N): N;
     /**
      * The function checks if a binary search tree is valid by traversing it either recursively or iteratively.
-     * @param {N | null} node - The `node` parameter represents the root node of a binary search tree (BST).
+     * @param {N | null} subTreeRoot - The `node` parameter represents the root node of a binary search tree (BST).
      * @returns a boolean value.
      */
-    isSubtreeBST(node: N | null): boolean;
+    isSubtreeBST(subTreeRoot: N | null): boolean;
     /**
      * The function isBST checks if the binary tree is valid binary search tree.
      * @returns The `isBST()` function is returning a boolean value.
@@ -253,26 +254,14 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      */
     getSubTreeSize(subTreeRoot: N | null | undefined): number;
     /**
-     * The function `subTreeSum` calculates the sum of a specified property in a binary tree or subtree.
-     * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a binary
-     * tree or the ID of a binary tree node. It can also be `null` if there is no subtree.
-     * @param {BinaryTreeNodePropertyName} [propertyName] - propertyName is an optional parameter that specifies the
-     * property of the binary tree node to use for calculating the sum. It can be either 'key' or 'val'. If propertyName is
-     * not provided, it defaults to 'key'.
-     * @returns a number, which is the sum of the values of the specified property in the subtree rooted at `subTreeRoot`.
-     */
-    subTreeSum(subTreeRoot: N | BinaryTreeNodeKey | null, propertyName?: BinaryTreeNodePropertyName): number;
-    /**
-     * The function `subTreeAdd` adds a delta value to a specified property of each node in a subtree.
+     * The function `subTreeForeach` adds a delta value to a specified property of each node in a subtree.
      * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a binary
      * tree or the ID of a node in the binary tree. It can also be `null` if there is no subtree to add to.
-     * @param {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
-     * each node in the subtree should be incremented.
-     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * @param callback - The `callback` parameter is a function that takes a node as a parameter and returns a value.
      * specifies the property of the binary tree node that should be modified. If not provided, it defaults to 'key'.
      * @returns a boolean value.
      */
-    subTreeAdd(subTreeRoot: N | BinaryTreeNodeKey | null, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    subTreeForeach(subTreeRoot: N | BinaryTreeNodeKey | null, callback: (node: N) => any): boolean;
     /**
      * Performs a breadth-first search (bfs) on a binary tree, accumulating properties of each node based on their 'key' property.
      * @returns An array of binary tree node IDs.
@@ -311,87 +300,26 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * Performs a depth-first search (dfs) traversal on a binary tree and accumulates properties of each node based on the specified property name.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {string} nodeOrPropertyName - The name of the property to accumulate.
+     * @param loopType - The type of loop to use for the depth-first search traversal. The default value is `LoopType.ITERATIVE`.
      * @returns An array of values corresponding to the specified property.
      */
-    dfs(pattern: DFSOrderPattern, nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
+    dfs(pattern: DFSOrderPattern, nodeOrPropertyName: 'key', loopType?: LoopType): BinaryTreeNodeKey[];
     /**
      * Performs a depth-first search (dfs) traversal on a binary tree and accumulates the 'val' property of each node.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {'val'} nodeOrPropertyName - The name of the property to accumulate.
+     * @param loopType - The type of loop to use for the depth-first search traversal. The default value is `LoopType.ITERATIVE`.
      * @returns An array of 'val' properties from each node.
      */
-    dfs(pattern: DFSOrderPattern, nodeOrPropertyName: 'val'): N[];
+    dfs(pattern: DFSOrderPattern, nodeOrPropertyName: 'val', loopType?: LoopType): N[];
     /**
      * Performs a depth-first search (dfs) traversal on a binary tree and accumulates nodes themselves.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {'node'} nodeOrPropertyName - The name of the property to accumulate.
+     * @param loopType - The type of loop to use for the depth-first search traversal. The default value is `LoopType.ITERATIVE`.
      * @returns An array of binary tree nodes.
      */
-    dfs(pattern: DFSOrderPattern, nodeOrPropertyName: 'node'): N[];
-    /**
-     * Performs an iterative depth-first search (dfs) traversal on a binary tree and accumulates properties of each node based on their 'key' property.
-     * @returns An array of binary tree node IDs.
-     */
-    dfsIterative(): BinaryTreeNodeKey[];
-    /**
-     * Performs an iterative depth-first search (dfs) traversal on a binary tree and accumulates properties of each node based on their 'key' property.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
-     * @returns An array of values corresponding to the specified property.
-     */
-    dfsIterative(pattern: DFSOrderPattern): BinaryTreeNodeKey[];
-    /**
-     * Performs an iterative depth-first search (dfs) traversal on a binary tree and accumulates properties of each node based on the specified property name.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
-     * @param {string} nodeOrPropertyName - The name of the property to accumulate.
-     * @returns An array of values corresponding to the specified property.
-     */
-    dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
-    /**
-     * Performs an iterative depth-first search (dfs) traversal on a binary tree and accumulates the 'val' property of each node.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
-     * @param {'val'} nodeOrPropertyName - The name of the property to accumulate.
-     * @returns An array of 'val' properties from each node.
-     */
-    dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'val'): N['val'][];
-    /**
-     * Performs an iterative depth-first search (dfs) traversal on a binary tree and accumulates nodes themselves.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
-     * @param {'node'} nodeOrPropertyName - The name of the property to accumulate.
-     * @returns An array of binary tree nodes.
-     */
-    dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'node'): N[];
-    /**
-     * Performs a level-order traversal on a binary tree starting from the specified node and accumulates properties of each node based on their 'key' property.
-     * @returns An array of binary tree node IDs.
-     */
-    levelIterative(): BinaryTreeNodeKey[];
-    /**
-     * Performs a level-order traversal on a binary tree starting from the specified node and accumulates properties of each node based on their 'key' property.
-     * @param {N | null} node - The starting node for the level order traversal. If null, the root node of the tree is used as the starting node.
-     * @returns An array of binary tree node IDs.
-     */
-    levelIterative(node: N | null): BinaryTreeNodeKey[];
-    /**
-     * Performs a level-order traversal on a binary tree starting from the specified node and accumulates properties of each node based on the specified property name.
-     * @param {N | null} node - The starting node for the level order traversal. If null, the root node of the tree is used as the starting node.
-     * @param {string} nodeOrPropertyName - The name of the property to accumulate.
-     * @returns An array of values corresponding to the specified property.
-     */
-    levelIterative(node: N | null, nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
-    /**
-     * Performs a level-order traversal on a binary tree starting from the specified node and accumulates the 'val' property of each node.
-     * @param {N | null} node - The starting node for the level order traversal. If null, the root node of the tree is used as the starting node.
-     * @param {'val'} nodeOrPropertyName - The name of the property to accumulate.
-     * @returns An array of 'val' properties from each node.
-     */
-    levelIterative(node: N | null, nodeOrPropertyName: 'val'): N['val'][];
-    /**
-     * Performs a level-order traversal on a binary tree starting from the specified node and accumulates nodes themselves.
-     * @param {N | null} node - The starting node for the level order traversal. If null, the root node of the tree is used as the starting node.
-     * @param {'node'} nodeOrPropertyName - The name of the property to accumulate.
-     * @returns An array of binary tree nodes.
-     */
-    levelIterative(node: N | null, nodeOrPropertyName: 'node'): N[];
+    dfs(pattern: DFSOrderPattern, nodeOrPropertyName: 'node', loopType?: LoopType): N[];
     /**
      * Collects nodes from a binary tree by a specified property and organizes them into levels.
      * @returns A 2D array of AbstractBinaryTreeNodeProperty<N> objects.
@@ -477,11 +405,6 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * undefined.
      */
     protected _addTo(newNode: N | null, parent: N): N | null | undefined;
-    /**
-     * The function sets the loop type for a protected variable.
-     * @param {LoopType} value - The value parameter is of type LoopType.
-     */
-    protected _setLoopType(value: LoopType): void;
     /**
      * The function sets the root property of an object to a given value, and if the value is not null, it also sets the
      * parent property of the value to undefined.