data-structure-typed 1.36.8 → 1.37.0

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

@@ -48,12 +48,12 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
     createNode(key: BinaryTreeNodeKey, val?: N['val'], count?: number): N;
     /**
      * The function swaps the location of two nodes in a tree data structure.
-     * @param {N} srcNode - The source node that we want to swap with the destination node.
+     * @param {N} srcNode - The source node that we 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 with.
      * @returns the `destNode` after swapping its values with the `srcNode`.
      */
-    swapLocation(srcNode: N, destNode: N): N;
+    protected _swap(srcNode: N, destNode: N): N;
     /**
      * The `add` function adds a new node to a binary search tree, maintaining the tree's properties and balancing if
      * necessary.
@@ -93,43 +93,15 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      */
     perfectlyBalance(): boolean;
     /**
-     * The `remove` function removes a node from a binary search tree and returns the deleted node along with the parent
+     * 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.
      * @param {N | BinaryTreeNodeKey | null} nodeOrKey - The `nodeOrKey` parameter can be one of the following:
      * @param {boolean} [ignoreCount] - The `ignoreCount` parameter is an optional boolean parameter that determines
      * whether to ignore the count of the node being removed. If `ignoreCount` is set to `true`, the count of the node will
      * not be taken into account when removing it. If `ignoreCount` is set to `false
-     * @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, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
-    /**
-     * The function `getSubTreeCount` calculates the number of nodes and the sum of their counts in a subtree, using either
-     * recursive or iterative traversal.
-     * @param {N | null | undefined} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree in a
-     * binary tree.
-     * @returns The function `getSubTreeCount` returns an array `[number, number]`.
-     */
-    getSubTreeCount(subTreeRoot: N | null | undefined): [number, number];
-    /**
-     * The function `subTreeSumCount` calculates the sum of the `count` property of each node in a subtree, either
-     * recursively or iteratively.
-     * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
-     * in a binary tree. It can be either a `BinaryTreeNodeKey` (a unique identifier for a node in the binary tree) or
-     * `null` if the subtree is empty.
-     * @returns the sum of the count values of all nodes in the subtree rooted at `subTreeRoot`.
-     */
-    subTreeSumCount(subTreeRoot: N | BinaryTreeNodeKey | null): number;
-    /**
-     * The function `subTreeAddCount` recursively or iteratively traverses a binary tree and adds a given delta value to
-     * the `count` property of each node.
-     * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
-     * in a binary tree. It can be either a `BinaryTreeNodeKey` (a unique identifier for a node in the binary tree), a
-     * `BinaryTreeNode` object, or `null` if the subtree is empty.
-     * @param {number} delta - The delta parameter is a number that represents the amount by which the count of each node
-     * in the subtree should be increased or decreased.
-     * @returns a boolean value.
-     */
-    subTreeAddCount(subTreeRoot: N | BinaryTreeNodeKey | null, delta: number): boolean;
+    delete(nodeOrKey: N | BinaryTreeNodeKey, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
     /**
      * The function `getNodesByCount` returns an array of nodes that have a specific count property, either recursively or
      * using a queue.
@@ -146,7 +118,7 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      * @returns The BFSCount() function returns an array of numbers, specifically the count property of each node in the
      * bfs traversal.
      */
-    BFSCount(): number[];
+    bfsCount(): number[];
     /**
      * The function "listLevelsCount" takes a node and returns an array of arrays, where each inner array contains the
      * count property of each node at that level.
@@ -164,39 +136,6 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      * @returns The function `morrisCount` returns an array of numbers.
      */
     morrisCount(pattern?: DFSOrderPattern): number[];
-    /**
-     * The function dfsCountIterative performs an iterative depth-first search and returns an array of node counts based on
-     * the specified traversal pattern.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The pattern parameter is a string that specifies the traversal order for
-     * the Depth-First Search (dfs) algorithm. It can have three possible values: 'in', 'pre', or 'post'.
-     * @returns The dfsCountIterative function returns an array of numbers, which represents the count property of each node
-     * in the dfs traversal.
-     */
-    dfsCountIterative(pattern?: DFSOrderPattern): number[];
-    /**
-     * The dfsCount function returns an array of counts for each node in a depth-first search traversal.
-     * @param {DFSOrderPattern} [pattern] - The pattern parameter is an optional parameter that specifies the order in which
-     * the Depth-First Search (dfs) algorithm should traverse the nodes. It can have one of the following values:
-     * @returns The dfsCount function returns an array of numbers, specifically the count property of each node in the dfs
-     * traversal.
-     */
-    dfsCount(pattern?: DFSOrderPattern): number[];
-    /**
-     * The `lesserSumCount` function calculates the sum of the counts of all nodes in a binary tree that have a lesser
-     * value than a given node.
-     * @param {N | BinaryTreeNodeKey | null} beginNode - The `beginNode` parameter can be one of the following:
-     * @returns the sum of the counts of nodes in the binary tree that have a lesser value than the given beginNode.
-     */
-    lesserSumCount(beginNode: N | BinaryTreeNodeKey | null): number;
-    /**
-     * The function `allGreaterNodesAddCount` updates the count property of all nodes in a binary tree that have an ID
-     * greater than a given ID by a specified delta value.
-     * @param {N | BinaryTreeNodeKey | null} node - The `node` parameter can be one of the following:
-     * @param {number} delta - The `delta` parameter is a number that represents the amount by which the `count` property
-     * of each node should be increased.
-     * @returns a boolean value.
-     */
-    allGreaterNodesAddCount(node: N | BinaryTreeNodeKey | null, delta: number): boolean;
     /**
      * The clear() function clears the data and sets the count to 0.
      */

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

@@ -1,5 +1,6 @@
 import { CP, FamilyPosition, LoopType } from '../../types';
 import { AVLTree, AVLTreeNode } from './avl-tree';
+import { Queue } from '../queue';
 export class TreeMultisetNode extends AVLTreeNode {
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
@@ -47,12 +48,12 @@ export class TreeMultiset extends AVLTree {
     }
     /**
      * The function swaps the location of two nodes in a tree data structure.
-     * @param {N} srcNode - The source node that we want to swap with the destination node.
+     * @param {N} srcNode - The source node that we 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 with.
      * @returns the `destNode` after swapping its values with the `srcNode`.
      */
-    swapLocation(srcNode, destNode) {
+    _swap(srcNode, destNode) {
         const { key, val, count, height } = destNode;
         const tempNode = this.createNode(key, val, count);
         if (tempNode) {
@@ -257,15 +258,15 @@ export class TreeMultiset extends AVLTree {
         }
     }
     /**
-     * The `remove` function removes a node from a binary search tree and returns the deleted node along with the parent
+     * 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.
      * @param {N | BinaryTreeNodeKey | null} nodeOrKey - The `nodeOrKey` parameter can be one of the following:
      * @param {boolean} [ignoreCount] - The `ignoreCount` parameter is an optional boolean parameter that determines
      * whether to ignore the count of the node being removed. If `ignoreCount` is set to `true`, the count of the node will
      * not be taken into account when removing it. If `ignoreCount` is set to `false
-     * @returns The function `remove` returns an array of `BinaryTreeDeletedResult<N>` objects.
+     * @returns The function `delete` returns an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    remove(nodeOrKey, ignoreCount = false) {
+    delete(nodeOrKey, ignoreCount = false) {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
@@ -299,7 +300,7 @@ export class TreeMultiset extends AVLTree {
                 const leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : null;
                 if (leftSubTreeRightMost) {
                     const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
-                    orgCurrent = this.swapLocation(curr, leftSubTreeRightMost);
+                    orgCurrent = this._swap(curr, leftSubTreeRightMost);
                     if (parentOfLeftSubTreeMax) {
                         if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost) {
                             parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
@@ -321,110 +322,6 @@ export class TreeMultiset extends AVLTree {
         }
         return bstDeletedResult;
     }
-    /**
-     * The function `getSubTreeCount` calculates the number of nodes and the sum of their counts in a subtree, using either
-     * recursive or iterative traversal.
-     * @param {N | null | undefined} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree in a
-     * binary tree.
-     * @returns The function `getSubTreeCount` returns an array `[number, number]`.
-     */
-    getSubTreeCount(subTreeRoot) {
-        const res = [0, 0];
-        if (!subTreeRoot)
-            return res;
-        if (this.loopType === LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                res[0]++;
-                res[1] += cur.count;
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
-            };
-            _traverse(subTreeRoot);
-            return res;
-        }
-        else {
-            const stack = [subTreeRoot];
-            while (stack.length > 0) {
-                const cur = stack.pop();
-                res[0]++;
-                res[1] += cur.count;
-                cur.right && stack.push(cur.right);
-                cur.left && stack.push(cur.left);
-            }
-            return res;
-        }
-    }
-    /**
-     * The function `subTreeSumCount` calculates the sum of the `count` property of each node in a subtree, either
-     * recursively or iteratively.
-     * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
-     * in a binary tree. It can be either a `BinaryTreeNodeKey` (a unique identifier for a node in the binary tree) or
-     * `null` if the subtree is empty.
-     * @returns the sum of the count values of all nodes in the subtree rooted at `subTreeRoot`.
-     */
-    subTreeSumCount(subTreeRoot) {
-        if (typeof subTreeRoot === 'number')
-            subTreeRoot = this.get(subTreeRoot, 'key');
-        if (!subTreeRoot)
-            return 0;
-        let sum = 0;
-        if (this.loopType === LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                sum += cur.count;
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
-            };
-            _traverse(subTreeRoot);
-        }
-        else {
-            const stack = [subTreeRoot];
-            while (stack.length > 0) {
-                const cur = stack.pop();
-                sum += cur.count;
-                cur.right && stack.push(cur.right);
-                cur.left && stack.push(cur.left);
-            }
-        }
-        return sum;
-    }
-    /**
-     * The function `subTreeAddCount` recursively or iteratively traverses a binary tree and adds a given delta value to
-     * the `count` property of each node.
-     * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
-     * in a binary tree. It can be either a `BinaryTreeNodeKey` (a unique identifier for a node in the binary tree), a
-     * `BinaryTreeNode` object, or `null` if the subtree is empty.
-     * @param {number} delta - The delta parameter is a number that represents the amount by which the count of each node
-     * in the subtree should be increased or decreased.
-     * @returns a boolean value.
-     */
-    subTreeAddCount(subTreeRoot, delta) {
-        if (typeof subTreeRoot === 'number')
-            subTreeRoot = this.get(subTreeRoot, 'key');
-        if (!subTreeRoot)
-            return false;
-        const _addByProperty = (cur) => {
-            cur.count += delta;
-            this._setCount(this.count + delta);
-        };
-        if (this.loopType === LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                _addByProperty(cur);
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
-            };
-            _traverse(subTreeRoot);
-        }
-        else {
-            const stack = [subTreeRoot];
-            while (stack.length > 0) {
-                const cur = stack.pop();
-                _addByProperty(cur);
-                cur.right && stack.push(cur.right);
-                cur.left && stack.push(cur.left);
-            }
-        }
-        return true;
-    }
     /**
      * The function `getNodesByCount` returns an array of nodes that have a specific count property, either recursively or
      * using a queue.
@@ -454,8 +351,8 @@ export class TreeMultiset extends AVLTree {
             _traverse(this.root);
         }
         else {
-            const queue = [this.root];
-            while (queue.length > 0) {
+            const queue = new Queue([this.root]);
+            while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
                     if (cur.count === nodeProperty) {
@@ -475,7 +372,7 @@ export class TreeMultiset extends AVLTree {
      * @returns The BFSCount() function returns an array of numbers, specifically the count property of each node in the
      * bfs traversal.
      */
-    BFSCount() {
+    bfsCount() {
         const nodes = super.bfs('node');
         return nodes.map(node => node.count);
     }
@@ -502,150 +399,6 @@ export class TreeMultiset extends AVLTree {
         const nodes = super.morris(pattern, 'node');
         return nodes.map(node => node.count);
     }
-    /**
-     * The function dfsCountIterative performs an iterative depth-first search and returns an array of node counts based on
-     * the specified traversal pattern.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The pattern parameter is a string that specifies the traversal order for
-     * the Depth-First Search (dfs) algorithm. It can have three possible values: 'in', 'pre', or 'post'.
-     * @returns The dfsCountIterative function returns an array of numbers, which represents the count property of each node
-     * in the dfs traversal.
-     */
-    dfsCountIterative(pattern = 'in') {
-        const nodes = super.dfsIterative(pattern, 'node');
-        return nodes.map(node => node.count);
-    }
-    /**
-     * The dfsCount function returns an array of counts for each node in a depth-first search traversal.
-     * @param {DFSOrderPattern} [pattern] - The pattern parameter is an optional parameter that specifies the order in which
-     * the Depth-First Search (dfs) algorithm should traverse the nodes. It can have one of the following values:
-     * @returns The dfsCount function returns an array of numbers, specifically the count property of each node in the dfs
-     * traversal.
-     */
-    dfsCount(pattern = 'in') {
-        const nodes = super.dfs(pattern, 'node');
-        return nodes.map(node => node.count);
-    }
-    /**
-     * The `lesserSumCount` function calculates the sum of the counts of all nodes in a binary tree that have a lesser
-     * value than a given node.
-     * @param {N | BinaryTreeNodeKey | null} beginNode - The `beginNode` parameter can be one of the following:
-     * @returns the sum of the counts of nodes in the binary tree that have a lesser value than the given beginNode.
-     */
-    lesserSumCount(beginNode) {
-        if (typeof beginNode === 'number')
-            beginNode = this.get(beginNode, 'key');
-        if (!beginNode)
-            return 0;
-        if (!this.root)
-            return 0;
-        const key = beginNode.key;
-        let sum = 0;
-        if (this.loopType === LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                const compared = this._compare(cur.key, key);
-                if (compared === CP.eq) {
-                    if (cur.right)
-                        sum += this.subTreeSumCount(cur.right);
-                    return;
-                }
-                else if (compared === CP.lt) {
-                    if (cur.left)
-                        sum += this.subTreeSumCount(cur.left);
-                    sum += cur.count;
-                    if (cur.right)
-                        _traverse(cur.right);
-                    else
-                        return;
-                }
-                else {
-                    if (cur.left)
-                        _traverse(cur.left);
-                    else
-                        return;
-                }
-            };
-            _traverse(this.root);
-        }
-        else {
-            const queue = [this.root];
-            while (queue.length > 0) {
-                const cur = queue.shift();
-                if (cur) {
-                    const compared = this._compare(cur.key, key);
-                    if (compared === CP.eq) {
-                        if (cur.right)
-                            sum += this.subTreeSumCount(cur.right);
-                        return sum;
-                    }
-                    else if (compared === CP.lt) {
-                        // todo maybe a bug
-                        if (cur.left)
-                            sum += this.subTreeSumCount(cur.left);
-                        sum += cur.count;
-                        if (cur.right)
-                            queue.push(cur.right);
-                        else
-                            return sum;
-                    }
-                    else {
-                        if (cur.left)
-                            queue.push(cur.left);
-                        else
-                            return sum;
-                    }
-                }
-            }
-        }
-        return sum;
-    }
-    /**
-     * The function `allGreaterNodesAddCount` updates the count property of all nodes in a binary tree that have an ID
-     * greater than a given ID by a specified delta value.
-     * @param {N | BinaryTreeNodeKey | null} node - The `node` parameter can be one of the following:
-     * @param {number} delta - The `delta` parameter is a number that represents the amount by which the `count` property
-     * of each node should be increased.
-     * @returns a boolean value.
-     */
-    allGreaterNodesAddCount(node, delta) {
-        if (typeof node === 'number')
-            node = this.get(node, 'key');
-        if (!node)
-            return false;
-        const key = node.key;
-        if (!this.root)
-            return false;
-        if (this.loopType === LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                const compared = this._compare(cur.key, key);
-                if (compared === CP.gt)
-                    cur.count += delta;
-                if (!cur.left && !cur.right)
-                    return;
-                if (cur.left && this._compare(cur.left.key, key) === CP.gt)
-                    _traverse(cur.left);
-                if (cur.right && this._compare(cur.right.key, key) === CP.gt)
-                    _traverse(cur.right);
-            };
-            _traverse(this.root);
-            return true;
-        }
-        else {
-            const queue = [this.root];
-            while (queue.length > 0) {
-                const cur = queue.shift();
-                if (cur) {
-                    const compared = this._compare(cur.key, key);
-                    if (compared === CP.gt)
-                        cur.count += delta;
-                    if (cur.left && this._compare(cur.left.key, key) === CP.gt)
-                        queue.push(cur.left);
-                    if (cur.right && this._compare(cur.right.key, key) === CP.gt)
-                        queue.push(cur.right);
-                }
-            }
-            return true;
-        }
-    }
     /**
      * The clear() function clears the data and sets the count to 0.
      */

package/lib/data-structures/graph/abstract-graph.js

@@ -7,6 +7,7 @@
  */
 import { arrayRemove, uuidV4 } from '../../utils';
 import { PriorityQueue } from '../priority-queue';
+import { Queue } from '../queue';
 export class AbstractVertex {
     /**
      * The function is a protected constructor that takes an key and an optional value as parameters.
@@ -265,11 +266,11 @@ export class AbstractGraph {
                 return null;
             }
             const visited = new Map();
-            const queue = [vertex1];
+            const queue = new Queue([vertex1]);
             visited.set(vertex1, true);
             let cost = 0;
-            while (queue.length > 0) {
-                for (let i = 0; i < queue.length; i++) {
+            while (queue.size > 0) {
+                for (let i = 0; i < queue.size; i++) {
                     const cur = queue.shift();
                     if (cur === vertex2) {
                         return cost;

package/lib/data-structures/hash/hash-map.d.ts

@@ -48,7 +48,7 @@ export declare class HashMap<K, V> {
     private resizeTable;
     set(key: K, value: V): void;
     get(key: K): V | undefined;
-    remove(key: K): void;
+    delete(key: K): void;
     entries(): IterableIterator<[K, V]>;
     [Symbol.iterator](): IterableIterator<[K, V]>;
     clear(): void;

package/lib/data-structures/hash/hash-map.js

@@ -127,7 +127,7 @@ export class HashMap {
         }
         return undefined;
     }
-    remove(key) {
+    delete(key) {
         const index = this._hash(key);
         if (!this.table[index]) {
             return;

package/lib/data-structures/hash/hash-table.d.ts

@@ -90,13 +90,13 @@ export declare class HashTable<K, V> {
      */
     get(key: K): V | undefined;
     /**
-     * The remove function removes a key-value pair from a hash table.
+     * The delete function removes a key-value pair from a hash table.
      * @param {K} key - The `key` parameter represents the key of the key-value pair that needs to be removed from the hash
      * table.
-     * @returns Nothing is being returned. The `remove` method has a return type of `void`, which means it does not return
+     * @returns Nothing is being returned. The `delete` method has a return type of `void`, which means it does not return
      * any value.
      */
-    remove(key: K): void;
+    delete(key: K): void;
     /**
      * The `expand` function increases the capacity of a hash table by creating a new array of buckets with double the
      * capacity and rehashing all the existing key-value pairs into the new buckets.

package/lib/data-structures/hash/hash-table.js

@@ -178,13 +178,13 @@ export class HashTable {
         return undefined; // Key not found
     }
     /**
-     * The remove function removes a key-value pair from a hash table.
+     * The delete function removes a key-value pair from a hash table.
      * @param {K} key - The `key` parameter represents the key of the key-value pair that needs to be removed from the hash
      * table.
-     * @returns Nothing is being returned. The `remove` method has a return type of `void`, which means it does not return
+     * @returns Nothing is being returned. The `delete` method has a return type of `void`, which means it does not return
      * any value.
      */
-    remove(key) {
+    delete(key) {
         const index = this._hash(key);
         let currentNode = this._buckets[index];
         let prevNode = null;

package/lib/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/lib/data-structures/linked-list/skip-linked-list.js

@@ -105,12 +105,12 @@ export 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/lib/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/lib/data-structures/queue/deque.js

@@ -251,12 +251,12 @@ export 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/lib/data-structures/queue/queue.js

@@ -90,7 +90,7 @@ export 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/lib/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/lib/data-structures/trie/trie.js

@@ -96,10 +96,10 @@ export 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/lib/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>[];
 }