data-structure-typed 1.36.8 → 1.36.9

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

@@ -47,12 +47,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 +257,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 +299,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;
@@ -475,7 +475,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);
     }
@@ -507,22 +507,12 @@ export class TreeMultiset extends AVLTree {
      * 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'.
+     * @param loopType  - The loopType parameter is a string that specifies the type of loop to use when traversing the
      * @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');
+    dfsCount(pattern = 'in', loopType = LoopType.ITERATIVE) {
+        const nodes = super.dfs(pattern, 'node', loopType);
         return nodes.map(node => node.count);
     }
     /**

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>[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.36.8",
+  "version": "1.36.9",
   "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",
@@ -34,7 +34,7 @@
     "changelog": "auto-changelog",
     "coverage:badge": "istanbul-badges-readme",
     "ci": "env && npm run lint && npm run build && npm run update:individuals && npm run test && git fetch --tags && npm run changelog",
-    "publish:all": "npm run ci && npm publish && sh /scripts/publish_all_subs.sh && sh /scripts/publish_docs.sh"
+    "publish:all": "npm run ci && npm publish && sh scripts/publish_all_subs.sh && sh scripts/publish_docs.sh"
   },
   "repository": {
     "type": "git",
@@ -56,17 +56,17 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.36.6",
+    "avl-tree-typed": "^1.36.8",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.36.6",
-    "bst-typed": "^1.36.6",
+    "binary-tree-typed": "^1.36.8",
+    "bst-typed": "^1.36.8",
     "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.36.6",
+    "heap-typed": "^1.36.8",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",

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

@@ -33,13 +33,13 @@ export class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends B
   }
 
   /**
-   * 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.
    */
-  override swapLocation(srcNode: N, destNode: N): N {
+  protected override _swap(srcNode: N, destNode: N): N {
     const {key, val, height} = destNode;
     const tempNode = this.createNode(key, val);
 
@@ -85,14 +85,14 @@ export class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends B
   }
 
   /**
-   * 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.
    */
-  override remove(key: BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[] {
-    const deletedResults = super.remove(key);
+  override delete(key: BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[] {
+    const deletedResults = super.delete(key);
     for (const {needBalanced} of deletedResults) {
       if (needBalanced) {
         this._balancePath(needBalanced);