data-structure-typed 1.53.6 → 1.53.7

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

@@ -92,13 +92,100 @@ export class TrieNode {
  * 9. Spell Check: Checking the spelling of words.
  * 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']);
+ *
+ *     // Get all completions for a prefix
+ *     const gmailCompletions = autocomplete.getWords('gmail');
+ *     console.log(gmailCompletions); // ['gmail.com', 'gmail.co.nz', 'gmail.co.jp']
+ * @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
+ * // Autocomplete: Basic word suggestions
+ *     // Create a trie for autocomplete
+ *     const autocomplete = new Trie<string>([
+ *       'function',
+ *       'functional',
+ *       'functions',
+ *       'class',
+ *       'classes',
+ *       'classical',
+ *       'closure',
+ *       'const',
+ *       'constructor'
+ *     ]);
+ *
+ *     // 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']
+ *
+ *     // Test with non-matching prefix
+ *     console.log(autocomplete.getWords('xyz')); // []
+ * @example
+ * // Dictionary: Case-insensitive word lookup
+ *     // Create a case-insensitive dictionary
+ *     const dictionary = new Trie<string>([], { caseSensitive: false });
+ *
+ *     // Add words with mixed casing
+ *     dictionary.add('Hello');
+ *     dictionary.add('WORLD');
+ *     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
+ * @example
+ * // IP Address Routing Table
+ *     // Add IP address prefixes and their corresponding routes
+ *     const routes = {
+ *       '192.168.1': 'LAN_SUBNET_1',
+ *       '192.168.2': 'LAN_SUBNET_2',
+ *       '10.0.0': 'PRIVATE_NETWORK_1',
+ *       '10.0.1': 'PRIVATE_NETWORK_2'
+ *     };
+ *
+ *     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
+ *
+ *     // 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
  */
 export class Trie<R = any> extends IterableElementBase<string, R, Trie<R>> {
   /**
-   * The constructor function for the Trie class.
-   * @param words: Iterable string Initialize the trie with a set of words
-   * @param options?: TrieOptions Allow the user to pass in options for the trie
-   * @return This
+   * The constructor initializes a Trie data structure with optional options and words provided as
+   * input.
+   * @param {Iterable<string> | Iterable<R>} words - The `words` parameter in the constructor is an
+   * iterable containing either strings or elements of type `R`. It is used to initialize the Trie with
+   * a list of words or elements. If no `words` are provided, an empty iterable is used as the default
+   * value.
+   * @param [options] - The `options` parameter in the constructor is an optional object that can
+   * contain configuration options for the Trie data structure. One of the options it can have is
+   * `caseSensitive`, which is a boolean value indicating whether the Trie should be case-sensitive or
+   * not. If `caseSensitive` is set to `
    */
   constructor(words: Iterable<string> | Iterable<R> = [], options?: TrieOptions<R>) {
     super(options);
@@ -107,13 +194,7 @@ export class Trie<R = any> extends IterableElementBase<string, R, Trie<R>> {
       if (caseSensitive !== undefined) this._caseSensitive = caseSensitive;
     }
     if (words) {
-      for (const word of words) {
-        if (this.toElementFn) {
-          this.add(this.toElementFn(word as R));
-        } else {
-          this.add(word as string);
-        }
-      }
+      this.addMany(words);
     }
   }
 
@@ -175,6 +256,30 @@ export class Trie<R = any> extends IterableElementBase<string, R, Trie<R>> {
     return isNewWord;
   }
 
+  /**
+   * Time Complexity: O(n * l)
+   * Space Complexity: O(1)
+   *
+   * The `addMany` function in TypeScript takes an iterable of strings or elements of type R, converts
+   * them using a provided function if available, and adds them to a data structure while returning an
+   * array of boolean values indicating success.
+   * @param {Iterable<string> | Iterable<R>} words - The `words` parameter in the `addMany` function is
+   * an iterable that contains either strings or elements of type `R`.
+   * @returns The `addMany` method returns an array of boolean values indicating whether each word in
+   * the input iterable was successfully added to the data structure.
+   */
+  addMany(words: Iterable<string> | Iterable<R> = []): boolean[] {
+    const ans: boolean[] = [];
+    for (const word of words) {
+      if (this.toElementFn) {
+        ans.push(this.add(this.toElementFn(word as R)));
+      } else {
+        ans.push(this.add(word as string));
+      }
+    }
+    return ans;
+  }
+
   /**
    * Time Complexity: O(l), where l is the length of the input word.
    * Space Complexity: O(1) - Constant space.

package/src/index.ts

@@ -2,4 +2,4 @@ export * from './data-structures';
 export * from './utils';
 export * from './interfaces';
 export * from './types';
-export * from './constants';
+export * from './common';

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

@@ -1,6 +1,6 @@
 import { BinaryTree, BinaryTreeNode } from '../../../data-structures';
 import { IterationType, OptValue } from '../../common';
-import { DFSOperation } from '../../../constants';
+import { DFSOperation } from '../../../common';
 
 export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 

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

@@ -1,13 +1,14 @@
 import { BST, BSTNode } from '../../../data-structures';
 import type { BinaryTreeOptions } from './binary-tree';
-import { Comparator } from '../../common';
+import { Comparable } from '../../utils';
 
 export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
 export type BSTNested<K, V, R, NODE extends BSTNode<K, V, NODE>> = BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
 export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
-  comparator?: Comparator<K>
+  extractComparable?: (key: K) => Comparable
+  isReverse?: boolean;
 }
 
 export type BSTNOptKey<K> = K | undefined;

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

@@ -7,4 +7,4 @@ export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNo
 
 export type RedBlackTreeNested<K, V, R, NODE extends RedBlackTreeNode<K, V, NODE>> = RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type RBTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};
+export type RBTreeOptions<K, V, R> = Omit<BSTOptions<K, V, R>, 'isReverse'> & {};

package/src/types/utils/utils.ts

@@ -7,17 +7,23 @@ export type SpecifyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T,
 
 export type Any = string | number | bigint | boolean | symbol | undefined | object;
 
+export type Arithmetic = number | bigint;
+
 export type ComparablePrimitive = number | bigint | string | boolean;
 
-// TODO type safety looks not strict
-export type ComparableObject = { [key in string]: any } & (
-  | {
-      valueOf: () => ComparablePrimitive | ComparableObject;
-      toString?: () => string;
-    }
-  | {
-      toString: () => string;
-    }
-);
+export interface BaseComparableObject {
+  [key: string]: unknown;
+}
+
+export interface ValueComparableObject extends BaseComparableObject {
+  valueOf: () => ComparablePrimitive | ValueComparableObject;
+  toString?: () => string;
+}
+
+export interface StringComparableObject extends BaseComparableObject {
+  toString: () => string;
+}
+
+export type ComparableObject = ValueComparableObject | StringComparableObject;
 
 export type Comparable = ComparablePrimitive | Date | ComparableObject;

package/src/utils/utils.ts

@@ -226,7 +226,8 @@ export const roundFixed = (num: number, digit: number = 10) => {
  */
 function isPrimitiveComparable(value: unknown): value is ComparablePrimitive {
   const valueType = typeof value;
-  if (valueType === 'number') return !Number.isNaN(value);
+  if (valueType === 'number') return true;
+  // if (valueType === 'number') return !Number.isNaN(value);
   return valueType === 'bigint' || valueType === 'string' || valueType === 'boolean';
 }
 
@@ -274,7 +275,8 @@ export function isComparable(value: unknown, isForceObjectComparable = false): v
   if (isPrimitiveComparable(value)) return true;
 
   if (typeof value !== 'object') return false;
-  if (value instanceof Date) return !Number.isNaN(value.getTime());
+  if (value instanceof Date) return true;
+  // if (value instanceof Date) return !Number.isNaN(value.getTime());
   if (isForceObjectComparable) return true;
   const comparableValue = tryObjectToPrimitive(value);
   if (comparableValue === null || comparableValue === undefined) return false;

package/test/performance/data-structures/binary-tree/avl-tree.test.ts

@@ -19,6 +19,9 @@ suite
   .add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
     for (let i = 0; i < randomArray.length; i++) avlTree.get(randomArray[i]);
   })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} getNode`, () => {
+    for (let i = 0; i < randomArray.length; i++) avlTree.getNode(randomArray[i]);
+  })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} iterator`, () => {
     const entries = [...avlTree];
     return entries.length === HUNDRED_THOUSAND;

package/test/performance/data-structures/binary-tree/rb-tree.test.ts

@@ -23,9 +23,12 @@ suite
   .add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
     for (let i = 0; i < randomArray.length; i++) rbTree.get(randomArray[i]);
   })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} getNode`, () => {
+    for (let i = 0; i < randomArray.length; i++) rbTree.getNode(randomArray[i]);
+  })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} node mode add randomly`, () => {
     rbTreeNodeMode.clear();
-    for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
+    for (let i = 0; i < randomArray.length; i++) rbTreeNodeMode.add(randomArray[i]);
   })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} node mode get`, () => {
     for (let i = 0; i < randomArray.length; i++) rbTreeNodeMode.get(randomArray[i]);

package/test/performance/reportor.ts

@@ -8,6 +8,22 @@ import { PerformanceTest } from './types';
 const args = process.argv.slice(2);
 
 const { GREEN, BOLD, END, YELLOW, GRAY, CYAN, BG_YELLOW } = ConsoleColor;
+const isOnlyOrdered = true;
+const runOrder = [
+  'heap',
+  'avl-tree',
+  'rb-tree',
+  'doubly-linked-list',
+  'directed-graph',
+  'queue',
+  'deque',
+  'hash-map',
+  'trie',
+  'stack'
+  // 'singly-linked-list',
+  // 'priority-queue',
+  // 'binary-tree-overall'
+];
 
 const getRelativePath = (file: string) => {
   return path.relative(__dirname, file);
@@ -80,7 +96,7 @@ const composeReport = () => {
                                 #json-to-html {
                                 padding: 0 10px 20px;
                                 }
-                                
+
                                 .json-to-html-label {
                                     font-size: 2rem;
                                     margin: 2rem 0 0 3px;
@@ -92,19 +108,19 @@ const composeReport = () => {
                                   margin-top: 10px;
                                   font-size: 16px;
                                 }
-                            
+
                                 .content table th,
                                 .content table td {
                                   padding: 8px 12px;
                                   text-align: left;
                                   border: 1px solid #ddd;
                                 }
-                            
+
                                 .content table th {
                                   background-color: #f2f2f2;
                                   font-weight: bold;
                                 }
-                            
+
                                 .content table tr:nth-child(odd) {
                                   background-color: #ffffff;
                                 }
@@ -188,46 +204,35 @@ function replaceMarkdownContent(startMarker: string, endMarker: string, newText:
   });
 }
 
-const order = [
-  'heap',
-  'rb-tree',
-  'queue',
-  'deque',
-  'hash-map',
-  'trie',
-  'avl-tree',
-  'binary-tree-overall',
-  'directed-graph',
-  'doubly-linked-list',
-  'singly-linked-list',
-  'priority-queue',
-  'stack'
-];
-
-const sortedPerformanceTests = [...performanceTests].sort((a, b) => {
-  const indexA = order.indexOf(a.testName);
-  const indexB = order.indexOf(b.testName);
+const sortedPerformanceTests = (
+  isOnlyOrdered ? [...performanceTests].filter(test => runOrder.includes(test.testName)) : [...performanceTests]
+).sort((a, b) => {
+  const indexA = runOrder.indexOf(a.testName);
+  const indexB = runOrder.indexOf(b.testName);
 
-  // If both a and b are in the order, sort them according to their indices in the order.
+  // If both a and b are in the runOrder, sort them according to their indices in the runOrder.
   if (indexA !== -1 && indexB !== -1) {
     return indexA - indexB;
   }
 
-  // If there is only 'a' in the order, then place 'b' in front.
+  // If there is only 'a' in the runOrder, then place 'b' in front.
   if (indexA !== -1) {
     return 1;
   }
 
-  // If only b is in the order, then a should be placed before it.
+  // If only b is in the runOrder, then a should be placed before it.
   if (indexB !== -1) {
     return -1;
   }
 
-  // If neither a nor b are in order, keep their original order
+  // If neither a nor b are in runOrder, keep their original runOrder
   return 0;
 });
 
-console.log(`${GREEN} Found tests${END}: ${sortedPerformanceTests.map(test => test.testName)}`);
+console.log(`${GREEN} Found tests (${performanceTests.length})${END}: ${performanceTests.map(test => test.testName)}`);
+console.log(
+  `${GREEN} Running tests (${sortedPerformanceTests.length})${END}: ${sortedPerformanceTests.map(test => test.testName)}`
+);
 
 sortedPerformanceTests.forEach(item => {
   const { suite, testName, file } = item;
@@ -245,22 +250,22 @@ sortedPerformanceTests.forEach(item => {
           return {
             'test name': benchmark.name,
             'time taken (ms)': numberFix(benchmark.times.period * 1000, 2),
-            'executions per sec': numberFix(benchmark.hz, 2),
+            // 'executions per sec': numberFix(benchmark.hz, 2),
             // 'executed times': numberFix(benchmark.count, 0),
-            // 'sample mean (secs)': numberFix(benchmark.stats.mean, 2),
+            'sample mean (secs)': numberFix(benchmark.stats.mean, 2),
             'sample deviation': numberFix(benchmark.stats.deviation, 2)
           };
         });
 
         report[testName].testName = testName;
-        const isDone = completedCount === performanceTests.length;
+        const isDone = completedCount === sortedPerformanceTests.length;
         runTime = Number(runTime.toFixed(2));
         const isTimeWarn = runTime > 120;
         console.log(
           // `Files: ${GREEN}${testFileCount}${END} `,
           // `Suites: ${GREEN}${performanceTests.length}${END} `,
-          `Suites Progress: ${isDone ? GREEN : YELLOW}${completedCount}${END}/${isDone ? GREEN : YELLOW}${performanceTests.length}${END}`,
-          `Time: ${isTimeWarn ? YELLOW : GREEN}${runTime}s${END}`
+          `Suites Progress: ${isDone ? GREEN : YELLOW}${completedCount}${END}/${isDone ? GREEN : YELLOW}${sortedPerformanceTests.length}${END}`,
+          `Time Costs: ${isTimeWarn ? YELLOW : GREEN}${runTime}s${END}`
         );
         if (isDone) {
           composeReport();

package/test/unit/data-structures/binary-tree/avl-tree-multi-map.test.ts

@@ -736,7 +736,7 @@ describe('AVLTree toEntryFn', () => {
           { obj: { id: 5 } }
         ])
     ).toThrowError(
-      `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`
+      `When comparing object types, a custom extractComparable must be defined in the constructor's options parameter.`
     );
   });
 
@@ -744,7 +744,7 @@ describe('AVLTree toEntryFn', () => {
     const tree = new AVLTreeMultiMap<{ obj: { id: number } }, number>(
       [{ obj: { id: 1 } }, { obj: { id: 2 } }, { obj: { id: 3 } }, { obj: { id: 4 } }, { obj: { id: 5 } }],
       {
-        comparator: (a, b) => a.obj.id - b.obj.id
+        extractComparable: key => key.obj.id
       }
     );
 

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

@@ -103,9 +103,9 @@ describe('BinaryTree addMany', () => {
       [undefined, 22, 44, 33]
     );
     expect(tree.get(2)).toBe(22);
-    expect(tree.get(tree.getNodeByKey(3))).toBe(33);
-    expect(tree.get(tree.getNodeByKey(4))).toBe(44);
-    expect(tree.get(tree.getNodeByKey(1))).toBe(1);
+    expect(tree.get(tree.getNode(3))).toBe(33);
+    expect(tree.get(tree.getNode(4))).toBe(44);
+    expect(tree.get(tree.getNode(1))).toBe(1);
   });
 
   it('should addMany undefined and null', () => {
@@ -349,7 +349,7 @@ describe('BinaryTree', () => {
     expect(tree.isBST(tree.getNode(4), 'ITERATIVE')).toBe(true);
     expect(tree.getNodes(2, false, null)).toEqual([]);
     expect(tree.getNodes(undefined)).toEqual([]);
-    expect(tree.getNodes(tree.getNodeByKey(2), false, tree.root)).toEqual([tree.getNodeByKey(2)]);
+    expect(tree.getNodes(tree.getNode(2), false, tree.root)).toEqual([tree.getNode(2)]);
   });
 
   describe('should isKey', () => {
@@ -362,9 +362,9 @@ describe('BinaryTree', () => {
         expect(tree.isKey(-Infinity)).toBe(true);
       });
 
-      it('NaN should not be a key', () => {
-        expect(tree.isKey(NaN)).toBe(false);
-      });
+      // it('NaN should not be a key', () => {
+      //   expect(tree.isKey(NaN)).toBe(false);
+      // });
 
       it('strings should be a key', () => {
         expect(tree.isKey('hello')).toBe(true);
@@ -400,9 +400,9 @@ describe('BinaryTree', () => {
         expect(tree.isKey(new Date('2024-01-01'))).toBe(true);
       });
 
-      it('invalid Date objects should not be a key', () => {
-        expect(tree.isKey(new Date('invalid'))).toBe(false);
-      });
+      // it('invalid Date objects should not be a key', () => {
+      //   expect(tree.isKey(new Date('invalid'))).toBe(false);
+      // });
     });
 
     describe('arrays', () => {
@@ -1155,8 +1155,8 @@ describe('BinaryTree', () => {
     tree.add([3, 'B']);
     tree.add([7, 'C']);
 
-    expect(tree.getPathToRoot(undefined, 7)).toEqual([5, 7]);
-    expect(tree.getPathToRoot(undefined, 1)).toEqual([]);
+    expect(tree.getPathToRoot(7)).toEqual([7, 5]);
+    expect(tree.getPathToRoot(1)).toEqual([]);
   });
 
   it('should check if the tree is perfectly balanced', () => {

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

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BST, BSTNode } from '../../../../src';
+import { BinaryTreeNode, BST, BSTNode, Range } from '../../../../src';
 import { isDebugTest, isTestStackOverflow, SYSTEM_MAX_CALL_STACK } from '../../../config';
 
 const isDebug = isDebugTest;
@@ -974,7 +974,7 @@ describe('BST operations test recursively', () => {
 
   if (isTestStackOverflow) {
     it('should getLeftMost', () => {
-      const bst = new BST<number>([], { comparator: (a, b) => b - a });
+      const bst = new BST<number>([], { extractComparable: key => key });
       for (let i = 1; i <= SYSTEM_MAX_CALL_STACK; i++) bst.add(i);
 
       expect(() => {
@@ -1009,7 +1009,7 @@ describe('BST isBST', function () {
 
   it('isBST when variant is Max', () => {
     const bst = new BST<number, number>([1, 2, 3, 9, 8, 5, 6, 7, 4], {
-      comparator: (a, b) => b - a
+      isReverse: true
     });
     bst.addMany([1, 2, 3, 9, 8, 5, 6, 7, 4]);
     expect(bst.isBST()).toBe(true);
@@ -1529,3 +1529,79 @@ describe('BST iterative methods not map mode test', () => {
     expect(balanced.leaves(node => balanced.get(node?.key))).toEqual(['a', 'f', 'd', 'i']);
   });
 });
+
+describe('classic use', () => {
+  // Test case for finding the kth smallest element
+  it('@example Find kth smallest element', () => {
+    // Create a BST with some elements
+    const bst = new BST<number>([5, 3, 7, 1, 4, 6, 8]);
+    const sortedKeys = bst.dfs(node => node.key, 'IN');
+
+    // Helper function to find kth smallest
+    const findKthSmallest = (k: number): number | undefined => {
+      return sortedKeys[k - 1];
+    };
+
+    // Assertions
+    expect(findKthSmallest(1)).toBe(1);
+    expect(findKthSmallest(3)).toBe(4);
+    expect(findKthSmallest(7)).toBe(8);
+  });
+
+  // Test case for finding elements in a given range
+  it('@example Find elements in a range', () => {
+    const bst = new BST<number>([10, 5, 15, 3, 7, 12, 18]);
+    expect(bst.search(new Range(5, 10))).toEqual([10, 5, 7]);
+    expect(bst.search(new Range(4, 12))).toEqual([10, 12, 5, 7]);
+    expect(bst.search(new Range(4, 12, true, false))).toEqual([10, 5, 7]);
+    expect(bst.search(new Range(15, 20))).toEqual([15, 18]);
+    expect(bst.search(new Range(15, 20, false))).toEqual([18]);
+  });
+
+  // Test case for Huffman coding simulation
+  it('Huffman coding frequency simulation', () => {
+    // Create a BST to simulate Huffman tree
+    const frequencyBST = new BST<string, number>([
+      ['a', 5],
+      ['b', 9],
+      ['c', 12],
+      ['d', 13],
+      ['e', 16],
+      ['f', 45]
+    ]);
+
+    // Sort nodes by frequency
+    const sortedFrequencies = frequencyBST.dfs(node => ({ char: node.key, freq: node.value }), 'IN');
+
+    // Build Huffman tree simulation
+    expect(sortedFrequencies[0].char).toBe('a');
+    expect(sortedFrequencies[5].char).toBe('f');
+  });
+
+  // Test case for Lowest Common Ancestor (LCA)
+  it('@example Find lowest common ancestor', () => {
+    const bst = new BST<number>([20, 10, 30, 5, 15, 25, 35, 3, 7, 12, 18]);
+
+    function findFirstCommon(arr1: number[], arr2: number[]): number | undefined {
+      for (const num of arr1) {
+        if (arr2.indexOf(num) !== -1) {
+          return num;
+        }
+      }
+      return undefined;
+    }
+
+    // LCA helper function
+    const findLCA = (num1: number, num2: number): number | undefined => {
+      const path1 = bst.getPathToRoot(num1);
+      const path2 = bst.getPathToRoot(num2);
+      // Find the first common ancestor
+      return findFirstCommon(path1, path2);
+    };
+
+    // Assertions
+    expect(findLCA(3, 10)).toBe(7);
+    expect(findLCA(5, 35)).toBe(15);
+    expect(findLCA(20, 30)).toBe(25);
+  });
+});