data-structure-typed 1.53.7 → 1.53.9

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

@@ -1,8 +1,6 @@
-import { TreeMultiMap, TreeMultiMapNode } from '../../../data-structures';
-import type { RBTreeOptions } from './rb-tree';
+import { TreeMultiMapNode } from '../../../data-structures';
+import type { RedBlackTreeOptions } from './rb-tree';
 
-export type TreeMultiMapNodeNested<K, V> = TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+export type TreeMultiMapNodeNested<K, V> = TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, any>>>>>>>>>>
 
-export type TreeMultiMapNested<K, V, R, NODE extends TreeMultiMapNode<K, V, NODE>> = TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
-
-export type TreeMultiMapOptions<K, V, R> = RBTreeOptions<K, V, R> & {}
+export type TreeMultiMapOptions<K, V, R> = RedBlackTreeOptions<K, V, R> & {}

package/test/integration/index.html

@@ -102,7 +102,7 @@
   try {
     const { OrderedMap } = sdsl;
     const { RedBlackTree } = dataStructureTyped;
-    const cRBTree = new OrderedMap();
+    const cRedBlackTree = new OrderedMap();
     const rbTree = new RedBlackTree();
     const tS = performance.now();
     const n = 100000;
@@ -117,10 +117,10 @@
     rbTree.print(rbTree.root, { isShowRedBlackNIL: true });
     const cS = performance.now();
     for (let i = 1; i < 100000; i++) {
-      cRBTree.setElement(i, i);
+      cRedBlackTree.setElement(i, i);
     }
     console.log((performance.now() - cS).toFixed(2), `CRedBlackTree ${n.toLocaleString()} add`);
-    console.log(cRBTree.size(), `cRBTree.size()`);
+    console.log(cRedBlackTree.size(), `cRedBlackTree.size()`);
   } catch (e) {
     console.error(e);
   }

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

@@ -9,14 +9,14 @@ const { TEN_THOUSAND } = magnitude;
 const arr = getRandomIntArray(TEN_THOUSAND, 0, TEN_THOUSAND - 1, true);
 
 suite
-  .add(`${TEN_THOUSAND.toLocaleString()} RBTree add randomly`, () => {
+  .add(`${TEN_THOUSAND.toLocaleString()} RedBlackTree add randomly`, () => {
     rbTree.clear();
     for (let i = 0; i < arr.length; i++) rbTree.add(arr[i]);
   })
-  .add(`${TEN_THOUSAND.toLocaleString()} RBTree get randomly`, () => {
+  .add(`${TEN_THOUSAND.toLocaleString()} RedBlackTree get randomly`, () => {
     for (let i = 0; i < arr.length; i++) rbTree.get(arr[i]);
   })
-  .add(`${TEN_THOUSAND.toLocaleString()} RBTree add & delete randomly`, () => {
+  .add(`${TEN_THOUSAND.toLocaleString()} RedBlackTree add & delete randomly`, () => {
     rbTree.clear();
     for (let i = 0; i < arr.length; i++) rbTree.add(arr[i]);
     for (let i = 0; i < arr.length; i++) rbTree.delete(arr[i]);

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

@@ -626,18 +626,18 @@ describe('AVLTreeMultiMap iterative methods test', () => {
 
   it('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    treeMM.forEach((value, key) => {
-      mockCallback(value, key);
+    treeMM.forEach((key, value) => {
+      mockCallback(key, value);
     });
 
     expect(mockCallback.mock.calls.length).toBe(3);
-    expect(mockCallback.mock.calls[0]).toEqual(['a', 1]);
-    expect(mockCallback.mock.calls[1]).toEqual(['b', 2]);
-    expect(mockCallback.mock.calls[2]).toEqual(['c', 3]);
+    expect(mockCallback.mock.calls[0]).toEqual([1, 'a']);
+    expect(mockCallback.mock.calls[1]).toEqual([2, 'b']);
+    expect(mockCallback.mock.calls[2]).toEqual([3, 'c']);
   });
 
   it('filter should return a new tree with filtered elements', () => {
-    const filteredTree = treeMM.filter((value, key) => key > 1);
+    const filteredTree = treeMM.filter(key => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
       [2, 'b'],
@@ -646,12 +646,12 @@ describe('AVLTreeMultiMap iterative methods test', () => {
   });
 
   it('map should return a new tree with modified elements', () => {
-    const mappedTree = treeMM.map((value, key) => (key * 2).toString());
+    const mappedTree = treeMM.map((key, value) => [(key * 2).toString(), value]);
     expect(mappedTree.size).toBe(3);
     expect([...mappedTree]).toEqual([
-      [1, '2'],
-      [2, '4'],
-      [3, '6']
+      ['2', 'a'],
+      ['4', 'b'],
+      ['6', 'c']
     ]);
   });
 
@@ -736,7 +736,7 @@ describe('AVLTree toEntryFn', () => {
           { obj: { id: 5 } }
         ])
     ).toThrowError(
-      `When comparing object types, a custom extractComparable must be defined in the constructor's options parameter.`
+      `When comparing object types, a custom specifyComparable 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 } }],
       {
-        extractComparable: key => key.obj.id
+        specifyComparable: key => key.obj.id
       }
     );
 

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

@@ -386,18 +386,18 @@ describe('AVLTree iterative methods test', () => {
 
   it('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    avl.forEach((value, key) => {
-      mockCallback(value, key);
+    avl.forEach((key, value) => {
+      mockCallback(key, value);
     });
 
     expect(mockCallback.mock.calls.length).toBe(3);
-    expect(mockCallback.mock.calls[0]).toEqual(['a', 1]);
-    expect(mockCallback.mock.calls[1]).toEqual(['b', 2]);
-    expect(mockCallback.mock.calls[2]).toEqual(['c', 3]);
+    expect(mockCallback.mock.calls[0]).toEqual([1, 'a']);
+    expect(mockCallback.mock.calls[1]).toEqual([2, 'b']);
+    expect(mockCallback.mock.calls[2]).toEqual([3, 'c']);
   });
 
   it('filter should return a new tree with filtered elements', () => {
-    const filteredTree = avl.filter((value, key) => key > 1);
+    const filteredTree = avl.filter(key => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
       [2, 'b'],
@@ -406,12 +406,12 @@ describe('AVLTree iterative methods test', () => {
   });
 
   it('map should return a new tree with modified elements', () => {
-    const mappedTree = avl.map((value, key) => (key * 2).toString());
+    const mappedTree = avl.map((key, value) => [(key * 2).toString(), value]);
     expect(mappedTree.size).toBe(3);
     expect([...mappedTree]).toEqual([
-      [1, '2'],
-      [2, '4'],
-      [3, '6']
+      ['2', 'a'],
+      ['4', 'b'],
+      ['6', 'c']
     ]);
   });
 

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

@@ -733,41 +733,41 @@ describe('BinaryTree', () => {
     ]);
   });
 
-  it('should keyValueNodeEntryRawToNodeAndValue', () => {
-    const tree = new BinaryTree<number>();
-    const node0 = tree.keyValueNodeEntryRawToNodeAndValue(0);
-    expect(node0).toEqual([
-      {
-        _left: undefined,
-        _right: undefined,
-        key: 0,
-        parent: undefined,
-        value: undefined
-      },
-      undefined
-    ]);
-
-    const nodeUndefined = tree.keyValueNodeEntryRawToNodeAndValue(undefined);
-    expect(nodeUndefined).toEqual([undefined, undefined]);
-
-    const nodeNull = tree.keyValueNodeEntryRawToNodeAndValue(null);
-    expect(nodeNull).toEqual([null, undefined]);
-
-    const [, nodeWithSeparateValue] = tree.keyValueNodeEntryRawToNodeAndValue(7, 77);
-    expect(nodeWithSeparateValue).toBe(77);
-
-    expect(tree.keyValueNodeEntryRawToNodeAndValue([undefined, 2])).toEqual([undefined, undefined]);
-
-    expect(tree.keyValueNodeEntryRawToNodeAndValue(Symbol('test') as unknown as number)).toEqual([
-      undefined,
-      undefined
-    ]);
-
-    const bTree = new BinaryTree<number, number, { obj: { id: number } }>([], {
-      toEntryFn: (ele: { obj: { id: number } }) => [Symbol('test') as unknown as number, ele.obj.id]
-    });
-    expect(bTree.keyValueNodeEntryRawToNodeAndValue({ obj: { id: 1 } })).toEqual([undefined, undefined]);
-  });
+  // it('should keyValueNodeEntryRawToNodeAndValue', () => {
+  //   const tree = new BinaryTree<number>();
+  //   const node0 = tree.keyValueNodeEntryRawToNodeAndValue(0);
+  //   expect(node0).toEqual([
+  //     {
+  //       _left: undefined,
+  //       _right: undefined,
+  //       key: 0,
+  //       parent: undefined,
+  //       value: undefined
+  //     },
+  //     undefined
+  //   ]);
+  //
+  //   const nodeUndefined = tree.keyValueNodeEntryRawToNodeAndValue(undefined);
+  //   expect(nodeUndefined).toEqual([undefined, undefined]);
+  //
+  //   const nodeNull = tree.keyValueNodeEntryRawToNodeAndValue(null);
+  //   expect(nodeNull).toEqual([null, undefined]);
+  //
+  //   const [, nodeWithSeparateValue] = tree.keyValueNodeEntryRawToNodeAndValue(7, 77);
+  //   expect(nodeWithSeparateValue).toBe(77);
+  //
+  //   expect(tree.keyValueNodeEntryRawToNodeAndValue([undefined, 2])).toEqual([undefined, undefined]);
+  //
+  //   expect(tree.keyValueNodeEntryRawToNodeAndValue(Symbol('test') as unknown as number)).toEqual([
+  //     undefined,
+  //     undefined
+  //   ]);
+  //
+  //   const bTree = new BinaryTree<number, number, { obj: { id: number } }>([], {
+  //     toEntryFn: (ele: { obj: { id: number } }) => [Symbol('test') as unknown as number, ele.obj.id]
+  //   });
+  //   expect(bTree.keyValueNodeEntryRawToNodeAndValue({ obj: { id: 1 } })).toEqual([undefined, undefined]);
+  // });
 
   it('should replace value', () => {
     const tree = new BinaryTree<number, string>([4, 5, [1, '1'], 2, 3], { isMapMode: false });
@@ -1342,18 +1342,18 @@ describe('BinaryTree iterative methods test', () => {
 
   it('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    binaryTree.forEach((value, key) => {
-      mockCallback(value, key);
+    binaryTree.forEach((key, value) => {
+      mockCallback(key, value);
     });
 
     expect(mockCallback.mock.calls.length).toBe(3);
-    expect(mockCallback.mock.calls[0]).toEqual(['b', 2]);
-    expect(mockCallback.mock.calls[1]).toEqual(['a', 1]);
-    expect(mockCallback.mock.calls[2]).toEqual(['c', 3]);
+    expect(mockCallback.mock.calls[0]).toEqual([2, 'b']);
+    expect(mockCallback.mock.calls[1]).toEqual([1, 'a']);
+    expect(mockCallback.mock.calls[2]).toEqual([3, 'c']);
   });
 
   it('filter should return a new tree with filtered elements', () => {
-    const filteredTree = binaryTree.filter((value, key) => key > 1);
+    const filteredTree = binaryTree.filter((key, value) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
       [3, 'c'],
@@ -1362,12 +1362,12 @@ describe('BinaryTree iterative methods test', () => {
   });
 
   it('map should return a new tree with modified elements', () => {
-    const mappedTree = binaryTree.map((value, key) => (key * 2).toString());
+    const mappedTree = binaryTree.map((key, value) => [(key * 2).toString(), value]);
     expect(mappedTree.size).toBe(3);
     expect([...mappedTree]).toEqual([
-      [1, '2'],
-      [2, '4'],
-      [3, '6']
+      ['2', 'a'],
+      ['4', 'b'],
+      ['6', 'c']
     ]);
   });
 

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

@@ -58,7 +58,7 @@ describe('BST operations test', () => {
       [10, 10],
       [5, 5]
     ];
-    bst.addMany(idsAndValues, undefined, false);
+    bst.addMany(idsAndValues, [], false);
     expect(bst.root).toBeInstanceOf(BSTNode);
 
     if (bst.root) expect(bst.root.key).toBe(11);
@@ -450,26 +450,26 @@ describe('BST operations test', () => {
     expect(bfsNodes[2].key).toBe(16);
   });
 
-  it('should keyValueNodeEntryRawToNodeAndValue', () => {
-    const bst = new BST<number>();
-    const node0 = bst.keyValueNodeEntryRawToNodeAndValue(0);
-    expect(node0).toEqual([
-      {
-        _left: undefined,
-        _right: undefined,
-        key: 0,
-        parent: undefined,
-        value: undefined
-      },
-      undefined
-    ]);
-
-    const nodeUndefined = bst.keyValueNodeEntryRawToNodeAndValue(undefined);
-    expect(nodeUndefined).toEqual([undefined, undefined]);
-
-    const nodeNull = bst.keyValueNodeEntryRawToNodeAndValue(null);
-    expect(nodeNull).toEqual([undefined, undefined]);
-  });
+  // it('should keyValueNodeEntryRawToNodeAndValue', () => {
+  //   const bst = new BST<number>();
+  //   const node0 = bst.keyValueNodeEntryRawToNodeAndValue(0);
+  //   expect(node0).toEqual([
+  //     {
+  //       _left: undefined,
+  //       _right: undefined,
+  //       key: 0,
+  //       parent: undefined,
+  //       value: undefined
+  //     },
+  //     undefined
+  //   ]);
+  //
+  //   const nodeUndefined = bst.keyValueNodeEntryRawToNodeAndValue(undefined);
+  //   expect(nodeUndefined).toEqual([undefined, undefined]);
+  //
+  //   const nodeNull = bst.keyValueNodeEntryRawToNodeAndValue(null);
+  //   expect(nodeNull).toEqual([undefined, undefined]);
+  // });
 
   it('should replace value', () => {
     const tree = new BST<number, string>([4, 5, [1, '1'], 2, 3], { isMapMode: false });
@@ -489,6 +489,13 @@ describe('BST operations test', () => {
     expect(treeMap.getNode(1)?.value).toBe(undefined);
     expect(treeMap.get(1)).toBe('b');
   });
+
+  it('should search in range', () => {
+    const bst = new BST<number>([10, 5, 15, 3, 7, 12, 18]);
+    expect(bst.rangeSearch([4, 12])).toEqual([10, 12, 5, 7]);
+    expect(() => bst.rangeSearch([12, 4])).toThrow('low must be less than or equal to high');
+    expect(bst.rangeSearch([12, 12])).toEqual([12]);
+  });
 });
 
 describe('BST operations test recursively', () => {
@@ -974,7 +981,7 @@ describe('BST operations test recursively', () => {
 
   if (isTestStackOverflow) {
     it('should getLeftMost', () => {
-      const bst = new BST<number>([], { extractComparable: key => key });
+      const bst = new BST<number>([], { specifyComparable: key => key });
       for (let i = 1; i <= SYSTEM_MAX_CALL_STACK; i++) bst.add(i);
 
       expect(() => {
@@ -1103,18 +1110,18 @@ describe('BST iterative methods test', () => {
 
   it('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    bst.forEach((value, key) => {
-      mockCallback(value, key);
+    bst.forEach((key, value) => {
+      mockCallback(key, value);
     });
 
     expect(mockCallback.mock.calls.length).toBe(3);
-    expect(mockCallback.mock.calls[0]).toEqual(['a', 1]);
-    expect(mockCallback.mock.calls[1]).toEqual(['b', 2]);
-    expect(mockCallback.mock.calls[2]).toEqual(['c', 3]);
+    expect(mockCallback.mock.calls[0]).toEqual([1, 'a']);
+    expect(mockCallback.mock.calls[1]).toEqual([2, 'b']);
+    expect(mockCallback.mock.calls[2]).toEqual([3, 'c']);
   });
 
   it('filter should return a new tree with filtered elements', () => {
-    const filteredTree = bst.filter((value, key) => key > 1);
+    const filteredTree = bst.filter((key, value) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
       [2, 'b'],
@@ -1123,12 +1130,12 @@ describe('BST iterative methods test', () => {
   });
 
   it('map should return a new tree with modified elements', () => {
-    const mappedTree = bst.map((value, key) => (key * 2).toString());
+    const mappedTree = bst.map((key, value) => [(key * 2).toString(), value]);
     expect(mappedTree.size).toBe(3);
     expect([...mappedTree]).toEqual([
-      [1, '2'],
-      [2, '4'],
-      [3, '6']
+      ['2', 'a'],
+      ['4', 'b'],
+      ['6', 'c']
     ]);
   });
 
@@ -1340,26 +1347,26 @@ describe('BST operations not map mode test', () => {
     });
   });
 
-  it('should keyValueNodeEntryRawToNodeAndValue', () => {
-    const bst = new BST<number>([], { isMapMode: false });
-    const node0 = bst.keyValueNodeEntryRawToNodeAndValue(0);
-    expect(node0).toEqual([
-      {
-        _left: undefined,
-        _right: undefined,
-        key: 0,
-        parent: undefined,
-        value: undefined
-      },
-      undefined
-    ]);
-
-    const nodeUndefined = bst.keyValueNodeEntryRawToNodeAndValue(undefined);
-    expect(nodeUndefined).toEqual([undefined, undefined]);
-
-    const nodeNull = bst.keyValueNodeEntryRawToNodeAndValue(null);
-    expect(nodeNull).toEqual([undefined, undefined]);
-  });
+  // it('should keyValueNodeEntryRawToNodeAndValue', () => {
+  //   const bst = new BST<number>([], { isMapMode: false });
+  //   const node0 = bst.keyValueNodeEntryRawToNodeAndValue(0);
+  //   expect(node0).toEqual([
+  //     {
+  //       _left: undefined,
+  //       _right: undefined,
+  //       key: 0,
+  //       parent: undefined,
+  //       value: undefined
+  //     },
+  //     undefined
+  //   ]);
+  //
+  //   const nodeUndefined = bst.keyValueNodeEntryRawToNodeAndValue(undefined);
+  //   expect(nodeUndefined).toEqual([undefined, undefined]);
+  //
+  //   const nodeNull = bst.keyValueNodeEntryRawToNodeAndValue(null);
+  //   expect(nodeNull).toEqual([undefined, undefined]);
+  // });
 });
 
 describe('BST operations not map mode test recursively', () => {
@@ -1531,57 +1538,52 @@ describe('BST iterative methods not map mode test', () => {
 });
 
 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];
-    };
+  it('@example Merge 3 sorted datasets', () => {
+    const dataset1 = new BST<number, string>([
+      [1, 'A'],
+      [7, 'G']
+    ]);
+    const dataset2 = [
+      [2, 'B'],
+      [6, 'F']
+    ];
+    const dataset3 = new BST<number, string>([
+      [3, 'C'],
+      [5, 'E'],
+      [4, 'D']
+    ]);
 
-    // Assertions
-    expect(findKthSmallest(1)).toBe(1);
-    expect(findKthSmallest(3)).toBe(4);
-    expect(findKthSmallest(7)).toBe(8);
+    // Merge datasets into a single BinarySearchTree
+    const merged = new BST<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('@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.rangeSearch([4, 12], node => node.key.toString())).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.rangeSearch([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]);
 
+    // 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);
+    };
+
     function findFirstCommon(arr1: number[], arr2: number[]): number | undefined {
       for (const num of arr1) {
         if (arr2.indexOf(num) !== -1) {
@@ -1591,14 +1593,6 @@ describe('classic use', () => {
       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);