data-structure-typed 1.36.4 → 1.36.6

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

@@ -309,16 +309,22 @@ export class BinaryTree {
     }
     /**
      * The function calculates the depth of a node in a binary tree.
-     * @param {N | BinaryTreeNodeKey | null} beginRoot - The `beginRoot` parameter can be one of the following:
+     * @param {N | BinaryTreeNodeKey | null} distNode - The `distNode` parameter can be any node of the tree
+     * @param {N | BinaryTreeNodeKey | null} beginRoot - The `beginRoot` parameter can be the predecessor node of distNode
      * @returns the depth of the given node or binary tree.
      */
-    getDepth(beginRoot = this.root) {
+    getDepth(distNode, beginRoot = this.root) {
+        if (typeof distNode === 'number')
+            distNode = this.get(distNode, 'key');
         if (typeof beginRoot === 'number')
             beginRoot = this.get(beginRoot, 'key');
         let depth = 0;
-        while (beginRoot === null || beginRoot === void 0 ? void 0 : beginRoot.parent) {
+        while (distNode === null || distNode === void 0 ? void 0 : distNode.parent) {
+            if (distNode === beginRoot) {
+                return depth;
+            }
             depth++;
-            beginRoot = beginRoot.parent;
+            distNode = distNode.parent;
         }
         return depth;
     }

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

@@ -34,10 +34,8 @@ export class TreeNode {
         }
     }
     getHeight() {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const beginRoot = this;
-        let maxDepth = 1;
-        if (beginRoot) {
+        let maxDepth = 0;
+        if (this) {
             const bfs = (node, level) => {
                 if (level > maxDepth) {
                     maxDepth = level;
@@ -49,7 +47,7 @@ export class TreeNode {
                     }
                 }
             };
-            bfs(beginRoot, 1);
+            bfs(this, 0);
         }
         return maxDepth;
     }

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

@@ -5,8 +5,12 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
+/**
+ * TrieNode represents a node in the Trie data structure. It holds a character key, a map of children nodes,
+ * and a flag indicating whether it's the end of a word.
+ */
 export declare class TrieNode {
-    constructor(v: string);
+    constructor(key: string);
     private _key;
     get key(): string;
     set key(v: string);
@@ -17,41 +21,56 @@ export declare class TrieNode {
     get isEnd(): boolean;
     set isEnd(v: boolean);
 }
+/**
+ * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
+ */
 export declare class Trie {
     constructor(words?: string[], caseSensitive?: boolean);
     protected _root: TrieNode;
     get root(): TrieNode;
     set root(v: TrieNode);
-    private _caseSensitive;
+    private readonly _caseSensitive;
+    /**
+     * Add a word to the Trie structure.
+     * @param {string} word - The word to add.
+     * @returns {boolean} True if the word was successfully added.
+     */
     add(word: string): boolean;
-    has(input: string): boolean;
+    /**
+     * Check if the Trie contains a given word.
+     * @param {string} word - The word to check for.
+     * @returns {boolean} True if the word is present in the Trie.
+     */
+    has(word: string): boolean;
     private _caseProcess;
+    /**
+     * Remove a word from the Trie structure.
+     * @param{string} word - The word to remove.
+     * @returns {boolean} True if the word was successfully removed.
+     */
     remove(word: string): boolean;
     getHeight(): number;
     /**
-     * The function checks if a given input string has an absolute prefix in a tree data structure.Only can present as a prefix, not a word
-     * @param {string} input - The input parameter is a string that represents the input value for the function.
-     * @returns a boolean value.
+     * Check if a given input string has an absolute prefix in the Trie, meaning it's not a complete word.
+     * @param {string} input - The input string to check.
+     * @returns {boolean} True if it's an absolute prefix in the Trie.
      */
-    isAbsPrefix(input: string): boolean;
+    hasPurePrefix(input: string): boolean;
     /**
-     * The function checks if a given input string is a prefix of any existing string in a tree structure.Can present as a abs prefix or word
-     * @param {string} input - The input parameter is a string that represents the prefix we want to check.
-     * @returns a boolean value.
+     * Check if a given input string is a prefix of any existing word in the Trie, whether as an absolute prefix or a complete word.
+     * @param {string} input - The input string representing the prefix to check.
+     * @returns {boolean} True if it's a prefix in the Trie.
      */
-    isPrefix(input: string): boolean;
+    hasPrefix(input: string): boolean;
     /**
-     * The function checks if the input string is a common prefix in a Trie data structure.Check if the input string is the common prefix of all the words
-     * @param {string} input - The input parameter is a string that represents the common prefix that we want to check for
-     * in the Trie data structure.
-     * @returns a boolean value indicating whether the input string is a common prefix in the Trie data structure.
+     * Check if the input string is a common prefix in the Trie, meaning it's a prefix shared by all words in the Trie.
+     * @param {string} input - The input string representing the common prefix to check for.
+     * @returns {boolean} True if it's a common prefix in the Trie.
      */
-    isCommonPrefix(input: string): boolean;
+    hasCommonPrefix(input: string): boolean;
     /**
-     * The function `getLongestCommonPrefix` returns the longest common prefix among all the words stored in a Trie data
-     * structure.
-     * @returns The function `getLongestCommonPrefix` returns a string, which is the longest common prefix found in the
-     * Trie.
+     * Get the longest common prefix among all the words stored in the Trie.
+     * @returns {string} The longest common prefix found in the Trie.
      */
     getLongestCommonPrefix(): string;
     /**
@@ -59,7 +78,7 @@ export declare class Trie {
      * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
      * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
      * @param {number} max - The max count of words will be found
-     * @returns an array of strings.
+     * @returns {string[]} an array of strings.
      */
     getWords(prefix?: string, max?: number): string[];
 }

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

@@ -5,9 +5,13 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
+/**
+ * TrieNode represents a node in the Trie data structure. It holds a character key, a map of children nodes,
+ * and a flag indicating whether it's the end of a word.
+ */
 export class TrieNode {
-    constructor(v) {
-        this._key = v;
+    constructor(key) {
+        this._key = key;
         this._isEnd = false;
         this._children = new Map();
     }
@@ -30,6 +34,9 @@ export class TrieNode {
         this._isEnd = v;
     }
 }
+/**
+ * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
+ */
 export class Trie {
     constructor(words, caseSensitive = true) {
         this._root = new TrieNode('');
@@ -46,6 +53,11 @@ export class Trie {
     set root(v) {
         this._root = v;
     }
+    /**
+     * Add a word to the Trie structure.
+     * @param {string} word - The word to add.
+     * @returns {boolean} True if the word was successfully added.
+     */
     add(word) {
         word = this._caseProcess(word);
         let cur = this.root;
@@ -60,10 +72,15 @@ export class Trie {
         cur.isEnd = true;
         return true;
     }
-    has(input) {
-        input = this._caseProcess(input);
+    /**
+     * Check if the Trie contains a given word.
+     * @param {string} word - The word to check for.
+     * @returns {boolean} True if the word is present in the Trie.
+     */
+    has(word) {
+        word = this._caseProcess(word);
         let cur = this.root;
-        for (const c of input) {
+        for (const c of word) {
             const nodeC = cur.children.get(c);
             if (!nodeC)
                 return false;
@@ -71,12 +88,17 @@ export class Trie {
         }
         return cur.isEnd;
     }
-    _caseProcess(input) {
+    _caseProcess(str) {
         if (!this._caseSensitive) {
-            input = input.toLowerCase(); // Convert input to lowercase if case insensitive
+            str = str.toLowerCase(); // Convert str to lowercase if case-insensitive
         }
-        return input;
+        return str;
     }
+    /**
+     * Remove a word from the Trie structure.
+     * @param{string} word - The word to remove.
+     * @returns {boolean} True if the word was successfully removed.
+     */
     remove(word) {
         word = this._caseProcess(word);
         let isDeleted = false;
@@ -111,7 +133,7 @@ export class Trie {
     }
     getHeight() {
         const beginRoot = this.root;
-        let maxDepth = 1;
+        let maxDepth = 0;
         if (beginRoot) {
             const bfs = (node, level) => {
                 if (level > maxDepth) {
@@ -124,17 +146,17 @@ export class Trie {
                     }
                 }
             };
-            bfs(beginRoot, 1);
+            bfs(beginRoot, 0);
         }
         return maxDepth;
     }
     // --- start additional methods ---
     /**
-     * The function checks if a given input string has an absolute prefix in a tree data structure.Only can present as a prefix, not a word
-     * @param {string} input - The input parameter is a string that represents the input value for the function.
-     * @returns a boolean value.
+     * Check if a given input string has an absolute prefix in the Trie, meaning it's not a complete word.
+     * @param {string} input - The input string to check.
+     * @returns {boolean} True if it's an absolute prefix in the Trie.
      */
-    isAbsPrefix(input) {
+    hasPurePrefix(input) {
         input = this._caseProcess(input);
         let cur = this.root;
         for (const c of input) {
@@ -146,11 +168,11 @@ export class Trie {
         return !cur.isEnd;
     }
     /**
-     * The function checks if a given input string is a prefix of any existing string in a tree structure.Can present as a abs prefix or word
-     * @param {string} input - The input parameter is a string that represents the prefix we want to check.
-     * @returns a boolean value.
+     * Check if a given input string is a prefix of any existing word in the Trie, whether as an absolute prefix or a complete word.
+     * @param {string} input - The input string representing the prefix to check.
+     * @returns {boolean} True if it's a prefix in the Trie.
      */
-    isPrefix(input) {
+    hasPrefix(input) {
         input = this._caseProcess(input);
         let cur = this.root;
         for (const c of input) {
@@ -162,12 +184,11 @@ export class Trie {
         return true;
     }
     /**
-     * The function checks if the input string is a common prefix in a Trie data structure.Check if the input string is the common prefix of all the words
-     * @param {string} input - The input parameter is a string that represents the common prefix that we want to check for
-     * in the Trie data structure.
-     * @returns a boolean value indicating whether the input string is a common prefix in the Trie data structure.
+     * Check if the input string is a common prefix in the Trie, meaning it's a prefix shared by all words in the Trie.
+     * @param {string} input - The input string representing the common prefix to check for.
+     * @returns {boolean} True if it's a common prefix in the Trie.
      */
-    isCommonPrefix(input) {
+    hasCommonPrefix(input) {
         input = this._caseProcess(input);
         let commonPre = '';
         const dfs = (cur) => {
@@ -185,10 +206,8 @@ export class Trie {
         return commonPre === input;
     }
     /**
-     * The function `getLongestCommonPrefix` returns the longest common prefix among all the words stored in a Trie data
-     * structure.
-     * @returns The function `getLongestCommonPrefix` returns a string, which is the longest common prefix found in the
-     * Trie.
+     * Get the longest common prefix among all the words stored in the Trie.
+     * @returns {string} The longest common prefix found in the Trie.
      */
     getLongestCommonPrefix() {
         let commonPre = '';
@@ -209,7 +228,7 @@ export class Trie {
      * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
      * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
      * @param {number} max - The max count of words will be found
-     * @returns an array of strings.
+     * @returns {string[]} an array of strings.
      */
     getWords(prefix = '', max = Number.MAX_SAFE_INTEGER) {
         prefix = this._caseProcess(prefix);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.36.4",
+  "version": "1.36.6",
   "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",
@@ -54,17 +54,17 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.36.3",
+    "avl-tree-typed": "^1.36.4",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.36.3",
-    "bst-typed": "^1.36.3",
+    "binary-tree-typed": "^1.36.4",
+    "bst-typed": "^1.36.4",
     "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.3",
+    "heap-typed": "^1.36.4",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",

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

@@ -350,16 +350,20 @@ export class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode>
 
   /**
    * The function calculates the depth of a node in a binary tree.
-   * @param {N | BinaryTreeNodeKey | null} beginRoot - The `beginRoot` parameter can be one of the following:
+   * @param {N | BinaryTreeNodeKey | null} distNode - The `distNode` parameter can be any node of the tree
+   * @param {N | BinaryTreeNodeKey | null} beginRoot - The `beginRoot` parameter can be the predecessor node of distNode
    * @returns the depth of the given node or binary tree.
    */
-  getDepth(beginRoot: N | BinaryTreeNodeKey | null = this.root): number {
+  getDepth(distNode: N | BinaryTreeNodeKey | null, beginRoot: N | BinaryTreeNodeKey | null = this.root): number {
+    if (typeof distNode === 'number') distNode = this.get(distNode, 'key');
     if (typeof beginRoot === 'number') beginRoot = this.get(beginRoot, 'key');
-
     let depth = 0;
-    while (beginRoot?.parent) {
+    while (distNode?.parent) {
+      if (distNode === beginRoot) {
+        return depth;
+      }
       depth++;
-      beginRoot = beginRoot.parent;
+      distNode = distNode.parent;
     }
     return depth;
   }

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

@@ -47,10 +47,8 @@ export class TreeNode<V = any> {
   }
 
   getHeight() {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const beginRoot = this;
-    let maxDepth = 1;
-    if (beginRoot) {
+    let maxDepth = 0;
+    if (this) {
       const bfs = (node: TreeNode<V>, level: number) => {
         if (level > maxDepth) {
           maxDepth = level;
@@ -62,7 +60,7 @@ export class TreeNode<V = any> {
           }
         }
       };
-      bfs(beginRoot, 1);
+      bfs(this, 0);
     }
     return maxDepth;
   }

package/src/data-structures/trie/trie.ts

@@ -5,9 +5,14 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
+
+/**
+ * TrieNode represents a node in the Trie data structure. It holds a character key, a map of children nodes,
+ * and a flag indicating whether it's the end of a word.
+ */
 export class TrieNode {
-  constructor(v: string) {
-    this._key = v;
+  constructor(key: string) {
+    this._key = key;
     this._isEnd = false;
     this._children = new Map<string, TrieNode>();
   }
@@ -43,6 +48,9 @@ export class TrieNode {
   }
 }
 
+/**
+ * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
+ */
 export class Trie {
   constructor(words?: string[], caseSensitive = true) {
     this._root = new TrieNode('');
@@ -63,8 +71,14 @@ export class Trie {
   set root(v: TrieNode) {
     this._root = v;
   }
-  private _caseSensitive: boolean;
 
+  private readonly _caseSensitive: boolean;
+
+  /**
+   * Add a word to the Trie structure.
+   * @param {string} word - The word to add.
+   * @returns {boolean} True if the word was successfully added.
+   */
   add(word: string): boolean {
     word = this._caseProcess(word);
     let cur = this.root;
@@ -80,22 +94,34 @@ export class Trie {
     return true;
   }
 
-  has(input: string): boolean {
-    input = this._caseProcess(input);
+  /**
+   * Check if the Trie contains a given word.
+   * @param {string} word - The word to check for.
+   * @returns {boolean} True if the word is present in the Trie.
+   */
+  has(word: string): boolean {
+    word = this._caseProcess(word);
     let cur = this.root;
-    for (const c of input) {
+    for (const c of word) {
       const nodeC = cur.children.get(c);
       if (!nodeC) return false;
       cur = nodeC;
     }
     return cur.isEnd;
   }
-  private _caseProcess(input: string) {
+
+  private _caseProcess(str: string) {
     if (!this._caseSensitive) {
-      input = input.toLowerCase(); // Convert input to lowercase if case insensitive
+      str = str.toLowerCase(); // Convert str to lowercase if case-insensitive
     }
-    return input;
+    return str;
   }
+
+  /**
+   * Remove a word from the Trie structure.
+   * @param{string} word - The word to remove.
+   * @returns {boolean} True if the word was successfully removed.
+   */
   remove(word: string) {
     word = this._caseProcess(word);
     let isDeleted = false;
@@ -131,7 +157,7 @@ export class Trie {
 
   getHeight() {
     const beginRoot = this.root;
-    let maxDepth = 1;
+    let maxDepth = 0;
     if (beginRoot) {
       const bfs = (node: TrieNode, level: number) => {
         if (level > maxDepth) {
@@ -144,17 +170,18 @@ export class Trie {
           }
         }
       };
-      bfs(beginRoot, 1);
+      bfs(beginRoot, 0);
     }
     return maxDepth;
   }
+
   // --- start additional methods ---
   /**
-   * The function checks if a given input string has an absolute prefix in a tree data structure.Only can present as a prefix, not a word
-   * @param {string} input - The input parameter is a string that represents the input value for the function.
-   * @returns a boolean value.
+   * Check if a given input string has an absolute prefix in the Trie, meaning it's not a complete word.
+   * @param {string} input - The input string to check.
+   * @returns {boolean} True if it's an absolute prefix in the Trie.
    */
-  isAbsPrefix(input: string): boolean {
+  hasPurePrefix(input: string): boolean {
     input = this._caseProcess(input);
     let cur = this.root;
     for (const c of input) {
@@ -166,11 +193,11 @@ export class Trie {
   }
 
   /**
-   * The function checks if a given input string is a prefix of any existing string in a tree structure.Can present as a abs prefix or word
-   * @param {string} input - The input parameter is a string that represents the prefix we want to check.
-   * @returns a boolean value.
+   * Check if a given input string is a prefix of any existing word in the Trie, whether as an absolute prefix or a complete word.
+   * @param {string} input - The input string representing the prefix to check.
+   * @returns {boolean} True if it's a prefix in the Trie.
    */
-  isPrefix(input: string): boolean {
+  hasPrefix(input: string): boolean {
     input = this._caseProcess(input);
     let cur = this.root;
     for (const c of input) {
@@ -182,12 +209,11 @@ export class Trie {
   }
 
   /**
-   * The function checks if the input string is a common prefix in a Trie data structure.Check if the input string is the common prefix of all the words
-   * @param {string} input - The input parameter is a string that represents the common prefix that we want to check for
-   * in the Trie data structure.
-   * @returns a boolean value indicating whether the input string is a common prefix in the Trie data structure.
+   * Check if the input string is a common prefix in the Trie, meaning it's a prefix shared by all words in the Trie.
+   * @param {string} input - The input string representing the common prefix to check for.
+   * @returns {boolean} True if it's a common prefix in the Trie.
    */
-  isCommonPrefix(input: string): boolean {
+  hasCommonPrefix(input: string): boolean {
     input = this._caseProcess(input);
     let commonPre = '';
     const dfs = (cur: TrieNode) => {
@@ -202,10 +228,8 @@ export class Trie {
   }
 
   /**
-   * The function `getLongestCommonPrefix` returns the longest common prefix among all the words stored in a Trie data
-   * structure.
-   * @returns The function `getLongestCommonPrefix` returns a string, which is the longest common prefix found in the
-   * Trie.
+   * Get the longest common prefix among all the words stored in the Trie.
+   * @returns {string} The longest common prefix found in the Trie.
    */
   getLongestCommonPrefix(): string {
     let commonPre = '';
@@ -224,12 +248,13 @@ export class Trie {
    * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
    * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
    * @param {number} max - The max count of words will be found
-   * @returns an array of strings.
+   * @returns {string[]} an array of strings.
    */
   getWords(prefix = '', max = Number.MAX_SAFE_INTEGER): string[] {
     prefix = this._caseProcess(prefix);
     const words: string[] = [];
     let found = 0;
+
     function dfs(node: TrieNode, word: string) {
       for (const char of node.children.keys()) {
         const charNode = node.children.get(char);

package/test/unit/data-structures/binary-tree/binary-tree.test.ts

@@ -105,6 +105,19 @@ describe('BinaryTree', () => {
     expect(binaryTree.has(4)).toBe(false);
   });
 
+  test('should getDepth return correct depth', () => {
+    binaryTree.add(1);
+    expect(binaryTree.getDepth(1)).toBe(0);
+    binaryTree.add(2);
+    expect(binaryTree.getDepth(2)).toBe(1);
+    binaryTree.add(3);
+    expect(binaryTree.getDepth(3, 1)).toBe(1);
+    binaryTree.add(4);
+    expect(binaryTree.getDepth(4, 1)).toBe(2);
+    expect(binaryTree.getDepth(4)).toBe(2);
+    expect(binaryTree.getDepth(4, 2)).toBe(1);
+  });
+
   test('should traverse in-order', () => {
     binaryTree.add(4);
     binaryTree.add(2);

package/test/unit/data-structures/heap/heap.test.ts

@@ -28,7 +28,6 @@ describe('Heap Operation Test', () => {
     minHeap.add({key: 0, a: 'a0'});
 
     expect(minHeap.peek()).toEqual({a: 'a0', key: 0});
-    console.log('---', minHeap.toArray());
     expect(minHeap.toArray().map(item => ({a: item.a}))).toEqual([{a: 'a0'}, {a: 'a1'}, {a: 'a2'}, {a: 'a6'}]);
     let i = 0;
     const expectPolled = [{a: 'a0'}, {a: 'a1'}, {a: 'a2'}, {a: 'a6'}];

package/test/unit/data-structures/tree/tree.test.ts

@@ -29,11 +29,11 @@ describe('TreeNode', () => {
     child1.addChildren([grandchild1]);
     child2.addChildren([grandchild2]);
 
-    expect(rootNode.getHeight()).toBe(3); // Height of the tree should be 3
+    expect(rootNode.getHeight()).toBe(2); // Height of the tree should be 2
   });
 
   it('should handle nodes without children when calculating height', () => {
     const rootNode = new TreeNode<string>('1', 'Root Node');
-    expect(rootNode.getHeight()).toBe(1); // Height of a single node should be 1
+    expect(rootNode.getHeight()).toBe(0); // Height of a single node should be 0
   });
 });