binary-tree-typed 2.2.1 → 2.2.3

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

@@ -77,53 +77,99 @@ export declare class TrieNode {
  * 10. IP Routing: Used in certain types of IP routing algorithms.
  * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data.
  * @example
- * // Autocomplete: Prefix validation and checking
- *     const autocomplete = new Trie<string>(['gmail.com', 'gmail.co.nz', 'gmail.co.jp', 'yahoo.com', 'outlook.com']);
+ * // basic Trie creation and add words
+ *  // Create a simple Trie with initial words
+ *     const trie = new Trie(['apple', 'app', 'apply']);
  *
- *     // Get all completions for a prefix
- *     const gmailCompletions = autocomplete.getWords('gmail');
- *     console.log(gmailCompletions); // ['gmail.com', 'gmail.co.nz', 'gmail.co.jp']
+ *     // Verify size
+ *     console.log(trie.size); // 3;
+ *
+ *     // Check if words exist
+ *     console.log(trie.has('apple')); // true;
+ *     console.log(trie.has('app')); // true;
+ *
+ *     // Add a new word
+ *     trie.add('application');
+ *     console.log(trie.size); // 4;
  * @example
- * // File System Path Operations
- *     const fileSystem = new Trie<string>([
- *       '/home/user/documents/file1.txt',
- *       '/home/user/documents/file2.txt',
- *       '/home/user/pictures/photo.jpg',
- *       '/home/user/pictures/vacation/',
- *       '/home/user/downloads'
- *     ]);
+ * // Trie getWords and prefix search
+ *  const trie = new Trie(['apple', 'app', 'apply', 'application', 'apricot']);
  *
- *     // Find common directory prefix
- *     console.log(fileSystem.getLongestCommonPrefix()); // '/home/user/'
+ *     // Get all words with prefix 'app'
+ *     const appWords = trie.getWords('app');
+ *     console.log(appWords); // contains 'app';
+ *     console.log(appWords); // contains 'apple';
+ *     console.log(appWords); // contains 'apply';
+ *     console.log(appWords); // contains 'application';
+ *     expect(appWords).not.toContain('apricot');
+ * @example
+ * // Trie isPrefix and isAbsolutePrefix checks
+ *  const trie = new Trie(['tree', 'trial', 'trick', 'trip', 'trie']);
  *
- *     // List all files in a directory
- *     const documentsFiles = fileSystem.getWords('/home/user/documents/');
- *     console.log(documentsFiles); // ['/home/user/documents/file1.txt', '/home/user/documents/file2.txt']
+ *     // Check if string is a prefix of any word
+ *     console.log(trie.hasPrefix('tri')); // true;
+ *     console.log(trie.hasPrefix('tr')); // true;
+ *     console.log(trie.hasPrefix('xyz')); // false;
+ *
+ *     // Check if string is an absolute prefix (not a complete word)
+ *     console.log(trie.hasPurePrefix('tri')); // true;
+ *     console.log(trie.hasPurePrefix('tree')); // false; // 'tree' is a complete word
+ *
+ *     // Verify size
+ *     console.log(trie.size); // 5;
  * @example
- * // Autocomplete: Basic word suggestions
- *     // Create a trie for autocomplete
- *     const autocomplete = new Trie<string>([
- *       'function',
- *       'functional',
- *       'functions',
- *       'class',
- *       'classes',
- *       'classical',
- *       'closure',
- *       'const',
- *       'constructor'
- *     ]);
+ * // Trie delete and iteration
+ *  const trie = new Trie(['car', 'card', 'care', 'careful', 'can', 'cat']);
+ *
+ *     // Delete a word
+ *     trie.delete('card');
+ *     console.log(trie.has('card')); // false;
+ *
+ *     // Word with same prefix still exists
+ *     console.log(trie.has('care')); // true;
  *
- *     // Test autocomplete with different prefixes
- *     console.log(autocomplete.getWords('fun')); // ['functional', 'functions', 'function']
- *     console.log(autocomplete.getWords('cla')); // ['classes', 'classical', 'class']
- *     console.log(autocomplete.getWords('con')); // ['constructor', 'const']
+ *     // Size decreased
+ *     console.log(trie.size); // 5;
  *
- *     // Test with non-matching prefix
- *     console.log(autocomplete.getWords('xyz')); // []
+ *     // Iterate through all words
+ *     const allWords = [...trie];
+ *     console.log(allWords.length); // 5;
+ * @example
+ * // Trie for autocomplete search index
+ *  // Trie is perfect for autocomplete: O(m + k) where m is prefix length, k is results
+ *     const searchIndex = new Trie(['typescript', 'javascript', 'python', 'java', 'rust', 'ruby', 'golang', 'kotlin']);
+ *
+ *     // User types 'j' - get all suggestions
+ *     const jResults = searchIndex.getWords('j');
+ *     console.log(jResults); // contains 'javascript';
+ *     console.log(jResults); // contains 'java';
+ *     console.log(jResults.length); // 2;
+ *
+ *     // User types 'ja' - get more specific suggestions
+ *     const jaResults = searchIndex.getWords('ja');
+ *     console.log(jaResults); // contains 'javascript';
+ *     console.log(jaResults); // contains 'java';
+ *     console.log(jaResults.length); // 2;
+ *
+ *     // User types 'jav' - even more specific
+ *     const javResults = searchIndex.getWords('jav');
+ *     console.log(javResults); // contains 'javascript';
+ *     console.log(javResults); // contains 'java';
+ *     console.log(javResults.length); // 2;
+ *
+ *     // Check for common prefix
+ *
+ *     console.log(searchIndex.hasCommonPrefix('ja')); // false; // Not all words start with 'ja'
+ *
+ *     // Total words in index
+ *     console.log(searchIndex.size); // 8;
+ *
+ *     // Get height (depth of tree)
+ *     const height = searchIndex.getHeight();
+ *     console.log(typeof height); // 'number';
  * @example
  * // Dictionary: Case-insensitive word lookup
- *     // Create a case-insensitive dictionary
+ *  // Create a case-insensitive dictionary
  *     const dictionary = new Trie<string>([], { caseSensitive: false });
  *
  *     // Add words with mixed casing
@@ -132,14 +178,30 @@ export declare class TrieNode {
  *     dictionary.add('JavaScript');
  *
  *     // Test lookups with different casings
- *     console.log(dictionary.has('hello')); // true
- *     console.log(dictionary.has('HELLO')); // true
- *     console.log(dictionary.has('Hello')); // true
- *     console.log(dictionary.has('javascript')); // true
- *     console.log(dictionary.has('JAVASCRIPT')); // true
+ *     console.log(dictionary.has('hello')); // true;
+ *     console.log(dictionary.has('HELLO')); // true;
+ *     console.log(dictionary.has('Hello')); // true;
+ *     console.log(dictionary.has('javascript')); // true;
+ *     console.log(dictionary.has('JAVASCRIPT')); // true;
+ * @example
+ * // File System Path Operations
+ *  const fileSystem = new Trie<string>([
+ *       '/home/user/documents/file1.txt',
+ *       '/home/user/documents/file2.txt',
+ *       '/home/user/pictures/photo.jpg',
+ *       '/home/user/pictures/vacation/',
+ *       '/home/user/downloads'
+ *     ]);
+ *
+ *     // Find common directory prefix
+ *     console.log(fileSystem.getLongestCommonPrefix()); // '/home/user/';
+ *
+ *     // List all files in a directory
+ *     const documentsFiles = fileSystem.getWords('/home/user/documents/');
+ *     console.log(documentsFiles); // ['/home/user/documents/file1.txt', '/home/user/documents/file2.txt'];
  * @example
  * // IP Address Routing Table
- *     // Add IP address prefixes and their corresponding routes
+ *  // Add IP address prefixes and their corresponding routes
  *     const routes = {
  *       '192.168.1': 'LAN_SUBNET_1',
  *       '192.168.2': 'LAN_SUBNET_2',
@@ -150,13 +212,13 @@ export declare class TrieNode {
  *     const ipRoutingTable = new Trie<string>(Object.keys(routes));
  *
  *     // Check IP address prefix matching
- *     console.log(ipRoutingTable.hasPrefix('192.168.1')); // true
- *     console.log(ipRoutingTable.hasPrefix('192.168.2')); // true
+ *     console.log(ipRoutingTable.hasPrefix('192.168.1')); // true;
+ *     console.log(ipRoutingTable.hasPrefix('192.168.2')); // true;
  *
  *     // Validate IP address belongs to subnet
  *     const ip = '192.168.1.100';
  *     const subnet = ip.split('.').slice(0, 3).join('.');
- *     console.log(ipRoutingTable.hasPrefix(subnet)); // true
+ *     console.log(ipRoutingTable.hasPrefix(subnet)); // true;
  */
 export declare class Trie<R = any> extends IterableElementBase<string, R> {
     /**

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

@@ -17,6 +17,7 @@ export interface IBinaryTree<K = any, V = any, R = any> {
     createNode(key: K, value?: BinaryTreeNode<K, V>['value']): BinaryTreeNode<K, V>;
     createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): IBinaryTree<K, V, R>;
     add(keyOrNodeOrEntryOrRawElement: BTNRep<K, V, BinaryTreeNode<K, V>>, value?: V, count?: number): boolean;
+    set(keyOrNodeOrEntryOrRawElement: BTNRep<K, V, BinaryTreeNode<K, V>>, value?: V, count?: number): boolean;
     addMany(keysNodesEntriesOrRaws: Iterable<K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, values?: Iterable<V | undefined>): boolean[];
     delete(keyNodeEntryRawOrPredicate: R | BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V> | null>): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[];
     clear(): void;

package/dist/umd/binary-tree-typed.js

@@ -1473,6 +1473,17 @@ var binaryTreeTyped = (() => {
       }
       return false;
     }
+    /**
+     * Adds or updates a new node to the tree.
+     * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation adds the node at the first available position in a level-order (BFS) traversal. This is NOT a Binary Search Tree insertion. Time O(N), where N is the number of nodes. It must traverse level-by-level to find an empty slot. Space O(N) in the worst case for the BFS queue (e.g., a full last level).
+     *
+     * @param keyNodeOrEntry - The key, node, or entry to add or update.
+     * @param [value] - The value, if providing just a key.
+     * @returns True if the addition was successful, false otherwise.
+     */
+    set(keyNodeOrEntry, value) {
+      return this.add(keyNodeOrEntry, value);
+    }
     /**
      * Adds multiple items to the tree.
      * @remarks Time O(N * M), where N is the number of items to add and M is the size of the tree at insertion (due to O(M) `add` operation). Space O(M) (from `add`) + O(N) (for the `inserted` array).
@@ -1500,6 +1511,17 @@ var binaryTreeTyped = (() => {
       }
       return inserted;
     }
+    /**
+     * Adds or updates multiple items to the tree.
+     * @remarks Time O(N * M), where N is the number of items to add and M is the size of the tree at insertion (due to O(M) `add` operation). Space O(M) (from `add`) + O(N) (for the `inserted` array).
+     *
+     * @param keysNodesEntriesOrRaws - An iterable of items to add or update.
+     * @param [values] - An optional parallel iterable of values.
+     * @returns An array of booleans indicating the success of each individual `add` operation.
+     */
+    setMany(keysNodesEntriesOrRaws, values) {
+      return this.addMany(keysNodesEntriesOrRaws, values);
+    }
     /**
      * Merges another tree into this one by adding all its nodes.
      * @remarks Time O(N * M), same as `addMany`, where N is the size of `anotherTree` and M is the size of this tree. Space O(M) (from `add`).