data-structure-typed 1.36.3 → 1.36.5

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

@@ -5,21 +5,26 @@
  * @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._val = v;
+  constructor(key: string) {
+    this._key = key;
     this._isEnd = false;
     this._children = new Map<string, TrieNode>();
   }
 
-  private _val;
+  private _key;
 
-  get val(): string {
-    return this._val;
+  get key(): string {
+    return this._key;
   }
 
-  set val(v: string) {
-    this._val = v;
+  set key(v: string) {
+    this._key = v;
   }
 
   protected _children: Map<string, TrieNode>;
@@ -43,9 +48,13 @@ export class TrieNode {
   }
 }
 
+/**
+ * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
+ */
 export class Trie {
-  constructor(words?: string[]) {
+  constructor(words?: string[], caseSensitive = true) {
     this._root = new TrieNode('');
+    this._caseSensitive = caseSensitive;
     if (words) {
       for (const i of words) {
         this.add(i);
@@ -63,8 +72,16 @@ export class Trie {
     this._root = v;
   }
 
+  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 {
-    let cur = this._root;
+    word = this._caseProcess(word);
+    let cur = this.root;
     for (const c of word) {
       let nodeC = cur.children.get(c);
       if (!nodeC) {
@@ -77,9 +94,15 @@ export class Trie {
     return true;
   }
 
-  has(input: string): boolean {
-    let cur = this._root;
-    for (const c of 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 word) {
       const nodeC = cur.children.get(c);
       if (!nodeC) return false;
       cur = nodeC;
@@ -87,7 +110,20 @@ export class Trie {
     return cur.isEnd;
   }
 
+  private _caseProcess(str: string) {
+    if (!this._caseSensitive) {
+      str = str.toLowerCase(); // Convert str to lowercase if case-insensitive
+    }
+    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;
     const dfs = (cur: TrieNode, i: number): boolean => {
       const char = word[i];
@@ -119,14 +155,35 @@ export class Trie {
     return isDeleted;
   }
 
+  getHeight() {
+    const beginRoot = this.root;
+    let maxDepth = 0;
+    if (beginRoot) {
+      const bfs = (node: TrieNode, level: number) => {
+        if (level > maxDepth) {
+          maxDepth = level;
+        }
+        const {children} = node;
+        if (children) {
+          for (const child of children.entries()) {
+            bfs(child[1], level + 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 {
-    let cur = this._root;
+  hasPurePrefix(input: string): boolean {
+    input = this._caseProcess(input);
+    let cur = this.root;
     for (const c of input) {
       const nodeC = cur.children.get(c);
       if (!nodeC) return false;
@@ -136,12 +193,13 @@ 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 {
-    let cur = this._root;
+  hasPrefix(input: string): boolean {
+    input = this._caseProcess(input);
+    let cur = this.root;
     for (const c of input) {
       const nodeC = cur.children.get(c);
       if (!nodeC) return false;
@@ -151,50 +209,51 @@ 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) => {
-      commonPre += cur.val;
+      commonPre += cur.key;
       if (commonPre === input) return;
       if (cur.isEnd) return;
       if (cur && cur.children && cur.children.size === 1) dfs(Array.from(cur.children.values())[0]);
       else return;
     };
-    dfs(this._root);
+    dfs(this.root);
     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(): string {
     let commonPre = '';
     const dfs = (cur: TrieNode) => {
-      commonPre += cur.val;
+      commonPre += cur.key;
       if (cur.isEnd) return;
       if (cur && cur.children && cur.children.size === 1) dfs(Array.from(cur.children.values())[0]);
       else return;
     };
-    dfs(this._root);
+    dfs(this.root);
     return commonPre;
   }
 
   /**
    * The `getAll` function returns an array of all words in a Trie data structure that start with a given prefix.
-   * @param [prefix] - The `prefix` parameter is a string that represents the prefix that we want to search for in the
+   * @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.
-   * @returns an array of strings.
+   * @param {number} max - The max count of words will be found
+   * @returns {string[]} an array of strings.
    */
-  getAll(prefix = ''): string[] {
+  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()) {
@@ -204,11 +263,13 @@ export class Trie {
         }
       }
       if (node.isEnd) {
+        if (found > max - 1) return;
         words.push(word);
+        found++;
       }
     }
 
-    let startNode = this._root;
+    let startNode = this.root;
 
     if (prefix) {
       for (const c of prefix) {
@@ -216,8 +277,8 @@ export class Trie {
         if (nodeC) startNode = nodeC;
       }
     }
+    if (startNode !== this.root) dfs(startNode, prefix);
 
-    dfs(startNode, prefix);
     return words;
   }
 

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
   });
 });