binary-tree-typed 2.4.4 → 2.5.0

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

@@ -8,6 +8,7 @@
 
 import type { ElementCallback, TrieOptions } from '../../types';
 import { IterableElementBase } from '../base';
+import { ERR } from '../../common';
 
 /**
  * Node used by Trie to store one character and its children.
@@ -112,32 +113,6 @@ export 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
- * // basic Trie creation and add words
- *  // Create a simple Trie with initial words
- *     const trie = new Trie(['apple', 'app', 'apply']);
- *
- *     // 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
- * // Trie getWords and prefix search
- *  const trie = new Trie(['apple', 'app', 'apply', 'application', 'apricot']);
- *
- *     // 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']);
  *
@@ -153,23 +128,6 @@ export class TrieNode {
  *     // Verify size
  *     console.log(trie.size); // 5;
  * @example
- * // 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;
- *
- *     // Size decreased
- *     console.log(trie.size); // 5;
- *
- *     // 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']);
@@ -326,6 +284,32 @@ export class Trie<R = any> extends IterableElementBase<string, R> {
    * @remarks Time O(L), Space O(L)
    * @param word - Word to insert.
    * @returns True if the word was newly added.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // basic Trie creation and add words
+ *  // Create a simple Trie with initial words
+ *     const trie = new Trie(['apple', 'app', 'apply']);
+ *
+ *     // 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;
    */
 
   add(word: string): boolean {
@@ -353,6 +337,21 @@ export class Trie<R = any> extends IterableElementBase<string, R> {
    * @remarks Time O(ΣL), Space O(ΣL)
    * @param words - Iterable of strings (or raw records if toElementFn is provided).
    * @returns Array of per-word 'added' flags.
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Add multiple words
+ *  const trie = new Trie();
+ *     trie.addMany(['cat', 'car', 'card']);
+ *     console.log(trie.has('cat')); // true;
+ *     console.log(trie.has('car')); // true;
+ *     console.log(trie.size); // 3;
    */
 
   addMany(words: Iterable<string> | Iterable<R>): boolean[] {
@@ -372,6 +371,24 @@ export class Trie<R = any> extends IterableElementBase<string, R> {
    * @remarks Time O(L), Space O(1)
    * @param word - Word to search for.
    * @returns True if present.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Check if a word exists
+ *  const dict = new Trie(['apple', 'app', 'application']);
+ *
+ *     console.log(dict.has('app')); // true;
+ *     console.log(dict.has('apple')); // true;
+ *     console.log(dict.has('ap')); // false;
    */
 
   override has(word: string): boolean {
@@ -389,6 +406,20 @@ export class Trie<R = any> extends IterableElementBase<string, R> {
    * Check whether the trie is empty.
    * @remarks Time O(1), Space O(1)
    * @returns True if size is 0.
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Check if empty
+ *  const trie = new Trie();
+ *     console.log(trie.isEmpty()); // true;
+ *     trie.add('word');
+ *     console.log(trie.isEmpty()); // false;
    */
 
   isEmpty(): boolean {
@@ -399,6 +430,19 @@ export class Trie<R = any> extends IterableElementBase<string, R> {
    * Remove all words and reset to a fresh root.
    * @remarks Time O(1), Space O(1)
    * @returns void
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Remove all words
+ *  const trie = new Trie(['a', 'b', 'c']);
+ *     trie.clear();
+ *     console.log(trie.isEmpty()); // true;
    */
 
   clear(): void {
@@ -411,6 +455,34 @@ export class Trie<R = any> extends IterableElementBase<string, R> {
    * @remarks Time O(L), Space O(1)
    * @param word - Word to delete.
    * @returns True if a word was removed.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // 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;
+ *
+ *     // Size decreased
+ *     console.log(trie.size); // 5;
+ *
+ *     // Iterate through all words
+ *     const allWords = [...trie];
+ *     console.log(allWords.length); // 5;
    */
 
   delete(word: string): boolean {
@@ -498,6 +570,24 @@ export class Trie<R = any> extends IterableElementBase<string, R> {
    * @remarks Time O(L), Space O(1)
    * @param input - String to test as prefix.
    * @returns True if input matches a path from root.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Check if a prefix exists
+ *  const trie = new Trie(['hello', 'help', 'world']);
+ *
+ *     console.log(trie.hasPrefix('hel')); // true;
+ *     console.log(trie.hasPrefix('wor')); // true;
+ *     console.log(trie.hasPrefix('xyz')); // false;
    */
 
   hasPrefix(input: string): boolean {
@@ -536,6 +626,22 @@ export class Trie<R = any> extends IterableElementBase<string, R> {
    * Return the longest common prefix among all words.
    * @remarks Time O(H), Space O(1)
    * @returns The longest common prefix string.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Find shared prefix
+ *  const trie = new Trie(['flower', 'flow', 'flight']);
+ *
+ *     console.log(trie.getLongestCommonPrefix()); // 'fl';
    */
 
   getLongestCommonPrefix(): string {
@@ -557,6 +663,28 @@ export class Trie<R = any> extends IterableElementBase<string, R> {
    * @param [max] - Maximum number of words to return; default is Number.MAX_SAFE_INTEGER.
    * @param [isAllWhenEmptyPrefix] - When true, collect from root even if prefix is empty.
    * @returns Array of collected words (at most max).
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Trie getWords and prefix search
+ *  const trie = new Trie(['apple', 'app', 'apply', 'application', 'apricot']);
+ *
+ *     // 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');
    */
 
   getWords(prefix = '', max = Number.MAX_SAFE_INTEGER, isAllWhenEmptyPrefix = false): string[] {
@@ -598,6 +726,20 @@ export class Trie<R = any> extends IterableElementBase<string, R> {
    * Deep clone this trie by iterating and inserting all words.
    * @remarks Time O(ΣL), Space O(ΣL)
    * @returns A new trie with the same words and options.
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Create independent copy
+ *  const trie = new Trie(['hello', 'world']);
+ *     const copy = trie.clone();
+ *     copy.delete('hello');
+ *     console.log(trie.has('hello')); // true;
    */
 
   clone(): this {
@@ -612,6 +754,19 @@ export class Trie<R = any> extends IterableElementBase<string, R> {
    * @param predicate - Predicate (word, index, trie) → boolean to keep word.
    * @param [thisArg] - Value for `this` inside the predicate.
    * @returns A new trie containing words that satisfy the predicate.
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Filter words
+ *  const trie = new Trie(['cat', 'car', 'dog', 'card']);
+ *     const result = trie.filter(w => w.startsWith('ca'));
+ *     console.log(result.size); // 3;
    */
 
   filter(predicate: ElementCallback<string, R, boolean>, thisArg?: any): this {
@@ -626,6 +781,22 @@ export class Trie<R = any> extends IterableElementBase<string, R> {
     return results;
   }
 
+    /**
+   * Transform words
+  
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Transform words
+ *  const trie = new Trie(['hello', 'world']);
+ *     const upper = trie.map(w => w.toUpperCase());
+ *     console.log(upper.has('HELLO')); // true;
+   */
   map<RM>(callback: ElementCallback<string, R, string>, options?: TrieOptions<RM>, thisArg?: any): Trie<RM>;
 
   /**
@@ -651,7 +822,7 @@ export class Trie<R = any> extends IterableElementBase<string, R> {
     for (const x of this) {
       const v = thisArg === undefined ? callback(x, i++, this) : callback.call(thisArg, x, i++, this);
       if (typeof v !== 'string') {
-        throw new TypeError(`Trie.map callback must return string; got ${typeof v}`);
+        throw new TypeError(ERR.callbackReturnType('string', typeof v, 'Trie.map'));
       }
       newTrie.add(v);
     }

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

@@ -1 +1 @@
-export type SegmentTreeNodeVal = number;
+export {};

package/src/types/data-structures/linked-list/skip-linked-list.ts

@@ -1 +1,2 @@
-export type SkipLinkedListOptions = { maxLevel?: number; probability?: number };
+// SkipList types are co-located with the implementation in src/data-structures/linked-list/skip-linked-list.ts
+export {};

package/src/types/data-structures/queue/deque.ts

@@ -2,4 +2,11 @@ import { LinearBaseOptions } from '../base';
 
 export type DequeOptions<E, R> = {
   bucketSize?: number;
+
+  /**
+   * When the ratio of used buckets to total buckets falls below this threshold
+   * after a shift/pop, auto-compact is triggered. Set to 0 to disable.
+   * Default: 0.5 (compact when less than half the buckets are in use).
+   */
+  autoCompactRatio?: number;
 } & LinearBaseOptions<E, R>;

package/src/utils/utils.ts

@@ -77,8 +77,10 @@ export const getMSB = (value: number): number => {
  * error message to be thrown if the index is out of bounds. By default, if no message is provided when
  * calling the `rangeCheck` function, the message "Index out of bounds." will be used.
  */
-export const rangeCheck = (index: number, min: number, max: number, message = 'Index out of bounds.'): void => {
-  if (index < min || index > max) throw new RangeError(message);
+export const rangeCheck = (index: number, min: number, max: number, message?: string): void => {
+  if (index < min || index > max) {
+    throw new RangeError(message ?? `Index ${index} is out of range [${min}, ${max}].`);
+  }
 };
 
 /**