data-structure-typed 1.53.5 → 1.53.7

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

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

@@ -58,11 +58,7 @@ describe('Overall BinaryTree Test', () => {
   it('Should clone a BST works fine', () => {
     const bst = new BST<number>([3, 6, 7, 1, 9], {
       iterationType: 'RECURSIVE',
-      comparator: (a, b) => {
-        if (a > b) return -1;
-        if (a < b) return 1;
-        return 0;
-      }
+      isReverse: true
     });
     expect(bst.size).toBe(5);
     expect(bst.root?.key).toBe(6);
@@ -70,7 +66,7 @@ describe('Overall BinaryTree Test', () => {
     expect(bst.root?.left?.right?.key).toBe(7);
     expect(bst.root?.right?.key).toBe(3);
     expect(bst.root?.right?.right?.key).toBe(1);
-    expect(bst.getNodeByKey(9)?.right?.key).toBe(7);
+    expect(bst.getNode(9)?.right?.key).toBe(7);
     expect(bst.getHeight()).toBe(2);
     expect(bst.has(9)).toBe(true);
     expect(bst.has(7)).toBe(true);
@@ -81,7 +77,7 @@ describe('Overall BinaryTree Test', () => {
     expect(bst.root?.left?.key).toBe(9);
     expect(bst.root?.right?.key).toBe(3);
     expect(bst.root?.right?.right?.key).toBe(1);
-    expect(bst.getNodeByKey(6)?.left?.key).toBe(9);
+    expect(bst.getNode(6)?.left?.key).toBe(9);
     expect(bst.getHeight()).toBe(2);
     expect(bst.has(9)).toBe(true);
     expect(bst.has(7)).toBe(false);
@@ -92,7 +88,7 @@ describe('Overall BinaryTree Test', () => {
     expect(clonedBST.root?.left?.key).toBe(9);
     expect(clonedBST.root?.right?.key).toBe(3);
     expect(clonedBST.root?.right?.right?.key).toBe(1);
-    expect(clonedBST.getNodeByKey(6)?.left?.key).toBe(9);
+    expect(clonedBST.getNode(6)?.left?.key).toBe(9);
     expect(clonedBST.getHeight()).toBe(2);
     expect(clonedBST.has(9)).toBe(true);
     expect(clonedBST.has(7)).toBe(false);
@@ -102,11 +98,7 @@ describe('Overall BinaryTree Test', () => {
   it('Should clone a AVLTree works fine', () => {
     const avl = new AVLTree<number>([3, 6, 7, 1, 9], {
       iterationType: 'RECURSIVE',
-      comparator: (a, b) => {
-        if (a > b) return -1;
-        if (a < b) return 1;
-        return 0;
-      }
+      isReverse: true
     });
     expect(avl.size).toBe(5);
     avl.add(2);
@@ -117,7 +109,7 @@ describe('Overall BinaryTree Test', () => {
     expect(avl.root?.left?.left?.key).toBe(9);
     expect(avl.root?.right?.key).toBe(1);
     expect(avl.root?.right?.left?.key).toBe(2);
-    expect(avl.getNodeByKey(7)?.left?.key).toBe(9);
+    expect(avl.getNode(7)?.left?.key).toBe(9);
     expect(avl.getHeight()).toBe(3);
     expect(avl.has(9)).toBe(true);
     expect(avl.has(7)).toBe(true);
@@ -128,7 +120,7 @@ describe('Overall BinaryTree Test', () => {
     expect(avl.root?.left?.key).toBe(5);
     expect(avl.root?.right?.key).toBe(1);
     expect(avl.root?.right?.left?.key).toBe(2);
-    expect(avl.getNodeByKey(6)?.left?.key).toBe(undefined);
+    expect(avl.getNode(6)?.left?.key).toBe(undefined);
     expect(avl.getHeight()).toBe(3);
     expect(avl.has(9)).toBe(true);
     expect(avl.has(7)).toBe(false);
@@ -139,7 +131,7 @@ describe('Overall BinaryTree Test', () => {
     expect(clonedAVL.root?.left?.key).toBe(5);
     expect(clonedAVL.root?.right?.key).toBe(1);
     expect(clonedAVL.root?.right?.left?.key).toBe(2);
-    expect(clonedAVL.getNodeByKey(6)?.left?.key).toBe(undefined);
+    expect(clonedAVL.getNode(6)?.left?.key).toBe(undefined);
     expect(clonedAVL.getHeight()).toBe(3);
     expect(clonedAVL.has(9)).toBe(true);
     expect(clonedAVL.has(7)).toBe(false);
@@ -162,7 +154,7 @@ describe('Overall BinaryTree Test', () => {
     expect(tmm.root?.left?.left?.key).toBe(NaN);
     expect(tmm.root?.right?.key).toBe(7);
     expect(tmm.root?.right?.left?.key).toBe(5);
-    expect(tmm.getNodeByKey(7)?.left?.key).toBe(5);
+    expect(tmm.getNode(7)?.left?.key).toBe(5);
     expect(tmm.getHeight()).toBe(3);
     expect(tmm.has(9)).toBe(true);
     expect(tmm.has(7)).toBe(true);
@@ -174,7 +166,7 @@ describe('Overall BinaryTree Test', () => {
     expect(tmm.root?.left?.key).toBe(1);
     expect(tmm.root?.right?.key).toBe(9);
     expect(tmm.root?.right?.left?.key).toBe(5);
-    expect(tmm.getNodeByKey(6)?.left?.key).toBe(NaN);
+    expect(tmm.getNode(6)?.left?.key).toBe(NaN);
     expect(tmm.getHeight()).toBe(3);
     expect(tmm.has(9)).toBe(true);
     expect(tmm.has(7)).toBe(false);
@@ -187,7 +179,7 @@ describe('Overall BinaryTree Test', () => {
     expect(clonedTMM.root?.left?.key).toBe(1);
     expect(clonedTMM.root?.right?.key).toBe(5);
     expect(clonedTMM.root?.right?.left?.key).toBe(4);
-    expect(clonedTMM.getNodeByKey(6)?.left?.key).toBe(NaN);
+    expect(clonedTMM.getNode(6)?.left?.key).toBe(NaN);
     expect(clonedTMM.getHeight()).toBe(3);
     expect(clonedTMM.has(9)).toBe(true);
     expect(clonedTMM.has(7)).toBe(false);
@@ -209,7 +201,7 @@ describe('Overall BinaryTree Test', () => {
     expect(rbTree.root?.left?.left?.key).toBe(NaN);
     expect(rbTree.root?.right?.key).toBe(7);
     expect(rbTree.root?.right?.left?.key).toBe(5);
-    expect(rbTree.getNodeByKey(7)?.left?.key).toBe(5);
+    expect(rbTree.getNode(7)?.left?.key).toBe(5);
     expect(rbTree.getHeight()).toBe(3);
     expect(rbTree.has(9)).toBe(true);
     expect(rbTree.has(7)).toBe(true);
@@ -220,7 +212,7 @@ describe('Overall BinaryTree Test', () => {
     expect(rbTree.root?.left?.key).toBe(1);
     expect(rbTree.root?.right?.key).toBe(9);
     expect(rbTree.root?.right?.left?.key).toBe(5);
-    expect(rbTree.getNodeByKey(6)?.left?.key).toBe(NaN);
+    expect(rbTree.getNode(6)?.left?.key).toBe(NaN);
     expect(rbTree.getHeight()).toBe(3);
     expect(rbTree.has(9)).toBe(true);
     expect(rbTree.has(7)).toBe(false);
@@ -232,7 +224,7 @@ describe('Overall BinaryTree Test', () => {
     expect(clonedRbTree.root?.left?.key).toBe(1);
     expect(clonedRbTree.root?.right?.key).toBe(5);
     expect(clonedRbTree.root?.right?.left?.key).toBe(4);
-    expect(clonedRbTree.getNodeByKey(6)?.left?.key).toBe(NaN);
+    expect(clonedRbTree.getNode(6)?.left?.key).toBe(NaN);
     expect(clonedRbTree.getHeight()).toBe(3);
     expect(clonedRbTree.has(9)).toBe(true);
     expect(clonedRbTree.has(7)).toBe(false);

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

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BSTNode, RedBlackTree, RedBlackTreeNode } from '../../../../src';
+import { BinaryTreeNode, BSTNode, Range, RedBlackTree, RedBlackTreeNode } from '../../../../src';
 import { getRandomInt, getRandomIntArray, magnitude } from '../../../utils';
 import { OrderedMap } from 'js-sdsl';
 
@@ -819,3 +819,102 @@ describe('RedBlackTree - _deleteFixup', () => {
     ]);
   });
 });
+
+describe('classic use', () => {
+  it('Database Index: Add, Search, and Delete Records', () => {
+    const dbIndex = new RedBlackTree<number, string>();
+
+    // Insert records
+    dbIndex.add(1, 'Alice');
+    dbIndex.add(2, 'Bob');
+    dbIndex.add(3, 'Charlie');
+
+    // Search for records
+    expect(dbIndex.get(1)).toBe('Alice');
+    expect(dbIndex.get(2)).toBe('Bob');
+    expect(dbIndex.get(3)).toBe('Charlie');
+
+    // Delete a record
+    dbIndex.delete(2);
+    expect(dbIndex.get(2)).toBeUndefined();
+  });
+
+  it('@example Merge 3 sorted datasets', () => {
+    const dataset1 = new RedBlackTree<number, string>([
+      [1, 'A'],
+      [7, 'G']
+    ]);
+    const dataset2 = [
+      [2, 'B'],
+      [6, 'F']
+    ];
+    const dataset3 = new RedBlackTree<number, string>([
+      [3, 'C'],
+      [5, 'E'],
+      [4, 'D']
+    ]);
+
+    // Merge datasets into a single Red-Black Tree
+    const merged = new RedBlackTree<number, string>(dataset1);
+    merged.addMany(dataset2);
+    merged.merge(dataset3);
+
+    // Verify merged dataset is in sorted order
+    expect([...merged.values()]).toEqual(['A', 'B', 'C', 'D', 'E', 'F', 'G']);
+  });
+
+  // Test case for finding elements in a given range
+  it('Find elements in a range', () => {
+    const bst = new RedBlackTree<number>([10, 5, 15, 3, 7, 12, 18]);
+    expect(bst.search(new Range(5, 10))).toEqual([5, 10, 7]);
+    expect(bst.search(new Range(4, 12))).toEqual([5, 10, 12, 7]);
+    expect(bst.search(new Range(15, 20))).toEqual([15, 18]);
+  });
+
+  it('Timer List: Manage Timed Tasks', () => {
+    const timerList = new RedBlackTree<number, string>(); // Key: Time in ms, Value: Task Name
+
+    // Schedule tasks
+    timerList.add(100, 'Task A');
+    timerList.add(200, 'Task B');
+    timerList.add(50, 'Task C');
+
+    // Verify the order of tasks by retrieval
+    expect([...timerList.values()]).toEqual(['Task C', 'Task A', 'Task B']); // Sorted by key (time)
+
+    // Remove the earliest task
+    timerList.delete(50);
+    expect([...timerList.values()]).toEqual(['Task A', 'Task B']);
+  });
+
+  it('Scheduler: Manage Tasks by Priority', () => {
+    const scheduler = new RedBlackTree<number, string>(); // Key: Priority, Value: Task Name
+
+    // Add tasks with different priorities
+    scheduler.add(3, 'Low Priority Task');
+    scheduler.add(1, 'High Priority Task');
+    scheduler.add(2, 'Medium Priority Task');
+
+    // Verify the order of tasks by retrieval
+    expect([...scheduler.values()]).toEqual(['High Priority Task', 'Medium Priority Task', 'Low Priority Task']);
+
+    // Remove the highest priority task
+    scheduler.delete(1);
+    expect([...scheduler.values()]).toEqual(['Medium Priority Task', 'Low Priority Task']);
+  });
+
+  it('Routing Table: Manage IP Routes', () => {
+    const routingTable = new RedBlackTree<number, string>(); // Key: IP Address, Value: Route
+
+    // Add routes
+    routingTable.add(1921680101, 'Route A');
+    routingTable.add(1921680102, 'Route B');
+    routingTable.add(1921680100, 'Route C');
+
+    // Search for a specific route
+    expect(routingTable.get(1921680101)).toBe('Route A');
+
+    // Verify all routes in sorted order
+    expect([...routingTable.values()]).toEqual(['Route C', 'Route A', 'Route B']);
+  });
+});