data-structure-typed 1.54.1 → 1.54.3

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

@@ -91,7 +91,7 @@ describe('AVLTreeCounter operations test1', () => {
     expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
-    if (node15) avlCounter.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) avlCounter.dfs(node => (subTreeSum += node.key), 'PRE', false, 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     avlCounter.lesserOrGreaterTraverse((node: AVLTreeCounterNode<number>) => (lesserSum += node.key), -1, 10);
@@ -99,7 +99,7 @@ describe('AVLTreeCounter operations test1', () => {
 
     expect(node15 instanceof AVLTreeCounterNode);
     if (node15 instanceof AVLTreeCounterNode) {
-      const subTreeAdd = avlCounter.dfs(node => (node.count += 1), 'PRE', 15);
+      const subTreeAdd = avlCounter.dfs(node => (node.count += 1), 'PRE', false, 15);
       expect(subTreeAdd);
     }
     const node11 = avlCounter.getNode(11);
@@ -347,7 +347,7 @@ describe('AVLTreeCounter operations test recursively1', () => {
     expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
-    if (node15) avlCounter.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) avlCounter.dfs(node => (subTreeSum += node.key), 'PRE', false, 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     avlCounter.lesserOrGreaterTraverse((node: AVLTreeCounterNode<number>) => (lesserSum += node.key), -1, 10);
@@ -355,7 +355,7 @@ describe('AVLTreeCounter operations test recursively1', () => {
 
     expect(node15 instanceof AVLTreeCounterNode);
     if (node15 instanceof AVLTreeCounterNode) {
-      const subTreeAdd = avlCounter.dfs(node => (node.count += 1), 'PRE', 15);
+      const subTreeAdd = avlCounter.dfs(node => (node.count += 1), 'PRE', false, 15);
       expect(subTreeAdd);
     }
     const node11 = avlCounter.getNode(11);
@@ -709,7 +709,7 @@ describe('AVLTreeCounter toEntryFn', () => {
 
     expect(avlCounter.morris(node => node.key, 'IN')).toEqual(expected);
     expect(avlCounter.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(avlCounter.dfs(node => node.key, 'IN', avlCounter.root, 'RECURSIVE')).toEqual(expected);
+    expect(avlCounter.dfs(node => node.key, 'IN', false, avlCounter.root, 'RECURSIVE')).toEqual(expected);
   });
 
   it('should toEntryFn 2', () => {
@@ -724,7 +724,7 @@ describe('AVLTreeCounter toEntryFn', () => {
 
     expect(avlCounter.morris(node => node.key, 'IN')).toEqual(expected);
     expect(avlCounter.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(avlCounter.dfs(node => node.key, 'IN', avlCounter.root, 'RECURSIVE')).toEqual(expected);
+    expect(avlCounter.dfs(node => node.key, 'IN', false, avlCounter.root, 'RECURSIVE')).toEqual(expected);
   });
 
   it('should toEntryFn throw error', () => {
@@ -760,7 +760,7 @@ describe('AVLTreeCounter toEntryFn', () => {
 
     expect(avlCounter.morris(node => node.key, 'IN')).toEqual(expected);
     expect(avlCounter.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(avlCounter.dfs(node => node.key, 'IN', avlCounter.root, 'RECURSIVE')).toEqual(expected);
+    expect(avlCounter.dfs(node => node.key, 'IN', false, avlCounter.root, 'RECURSIVE')).toEqual(expected);
   });
 });
 

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

@@ -50,7 +50,7 @@ describe('AVLTreeMultiMap Test', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -176,7 +176,7 @@ describe('AVLTreeMultiMap Test recursively', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -435,7 +435,7 @@ describe('AVLTreeMultiMap iterative methods test', () => {
   });
 
   it('map should return a new avlTmm with modified elements', () => {
-    const avlTmmMapped = avlTmm.map((key, value) => [(key * 2).toString(), value ? value :[]]);
+    const avlTmmMapped = avlTmm.map((key, value) => [(key * 2).toString(), value ? value : []]);
     expect(avlTmmMapped.size).toBe(3);
     expect([...avlTmmMapped]).toEqual([
       ['2', ['a']],
@@ -509,7 +509,7 @@ describe('AVLTreeMultiMap not map mode', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -527,7 +527,6 @@ describe('AVLTreeMultiMap not map mode test recursively', () => {
     const avlTmm = new AVLTreeMultiMap<number>([], { iterationType: 'RECURSIVE' });
 
     for (const i of arr) avlTmm.add([i, [i]]);
-
     const node6 = avlTmm.getNode(6);
 
     expect(node6 && avlTmm.getHeight(node6)).toBe(3);
@@ -544,7 +543,7 @@ describe('AVLTreeMultiMap not map mode test recursively', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;

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

@@ -1,4 +1,4 @@
-import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode } from '../../../../src';
+import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode, Range } from '../../../../src';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
@@ -24,7 +24,7 @@ describe('AVL Tree Test', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -150,7 +150,7 @@ describe('AVL Tree Test recursively', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -480,7 +480,7 @@ describe('AVL Tree not map mode', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -515,7 +515,7 @@ describe('AVL Tree not map mode test recursively', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -542,3 +542,70 @@ describe('AVLTree iterative methods not map mode', () => {
     expect(cloned.get(cloned.root?.right?.key)).toBe('c');
   });
 });
+
+describe('classic use', () => {
+  // Test case for finding elements in a given range
+  it('@example Find elements in a range', () => {
+    type Datum = { timestamp: Date; temperature: number };
+    // Fixed dataset of CPU temperature readings
+    const cpuData: Datum[] = [
+      { timestamp: new Date('2024-12-02T00:00:00'), temperature: 55.1 },
+      { timestamp: new Date('2024-12-02T00:01:00'), temperature: 56.3 },
+      { timestamp: new Date('2024-12-02T00:02:00'), temperature: 54.8 },
+      { timestamp: new Date('2024-12-02T00:03:00'), temperature: 57.2 },
+      { timestamp: new Date('2024-12-02T00:04:00'), temperature: 58.0 },
+      { timestamp: new Date('2024-12-02T00:05:00'), temperature: 59.4 },
+      { timestamp: new Date('2024-12-02T00:06:00'), temperature: 60.1 },
+      { timestamp: new Date('2024-12-02T00:07:00'), temperature: 61.3 },
+      { timestamp: new Date('2024-12-02T00:08:00'), temperature: 62.0 },
+      { timestamp: new Date('2024-12-02T00:09:00'), temperature: 63.5 },
+      { timestamp: new Date('2024-12-02T00:10:00'), temperature: 64.0 },
+      { timestamp: new Date('2024-12-02T00:11:00'), temperature: 62.8 },
+      { timestamp: new Date('2024-12-02T00:12:00'), temperature: 61.5 },
+      { timestamp: new Date('2024-12-02T00:13:00'), temperature: 60.2 },
+      { timestamp: new Date('2024-12-02T00:14:00'), temperature: 59.8 },
+      { timestamp: new Date('2024-12-02T00:15:00'), temperature: 58.6 },
+      { timestamp: new Date('2024-12-02T00:16:00'), temperature: 57.4 },
+      { timestamp: new Date('2024-12-02T00:17:00'), temperature: 56.2 },
+      { timestamp: new Date('2024-12-02T00:18:00'), temperature: 55.7 },
+      { timestamp: new Date('2024-12-02T00:19:00'), temperature: 54.5 },
+      { timestamp: new Date('2024-12-02T00:20:00'), temperature: 53.2 },
+      { timestamp: new Date('2024-12-02T00:21:00'), temperature: 52.8 },
+      { timestamp: new Date('2024-12-02T00:22:00'), temperature: 51.9 },
+      { timestamp: new Date('2024-12-02T00:23:00'), temperature: 50.5 },
+      { timestamp: new Date('2024-12-02T00:24:00'), temperature: 49.8 },
+      { timestamp: new Date('2024-12-02T00:25:00'), temperature: 48.7 },
+      { timestamp: new Date('2024-12-02T00:26:00'), temperature: 47.5 },
+      { timestamp: new Date('2024-12-02T00:27:00'), temperature: 46.3 },
+      { timestamp: new Date('2024-12-02T00:28:00'), temperature: 45.9 },
+      { timestamp: new Date('2024-12-02T00:29:00'), temperature: 45.0 }
+    ];
+
+    // Create an AVL tree to store CPU temperature data
+    const cpuTemperatureTree = new AVLTree<Date, number, Datum>(cpuData, {
+      toEntryFn: ({ timestamp, temperature }) => [timestamp, temperature]
+    });
+
+    // Query a specific time range (e.g., from 00:05 to 00:15)
+    const rangeStart = new Date('2024-12-02T00:05:00');
+    const rangeEnd = new Date('2024-12-02T00:15:00');
+    const rangeResults = cpuTemperatureTree.rangeSearch([rangeStart, rangeEnd], node => ({
+      minute: node ? node.key.getMinutes() : 0,
+      temperature: cpuTemperatureTree.get(node ? node.key : undefined)
+    }));
+
+    expect(rangeResults).toEqual( [
+            { minute: 5, temperature: 59.4 },
+            { minute: 6, temperature: 60.1 },
+            { minute: 7, temperature: 61.3 },
+            { minute: 8, temperature: 62 },
+            { minute: 9, temperature: 63.5 },
+            { minute: 10, temperature: 64 },
+            { minute: 11, temperature: 62.8 },
+            { minute: 12, temperature: 61.5 },
+            { minute: 13, temperature: 60.2 },
+            { minute: 14, temperature: 59.8 },
+            { minute: 15, temperature: 58.6 }
+          ]);
+  });
+});

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

@@ -217,20 +217,20 @@ describe('BinaryTree', () => {
     expect(cloned.root?.right?.key).toBe(6);
     expect(cloned.root?.right?.left?.key).toBe(3);
     expect(cloned.root?.right?.right).toBe(null);
-    expect(cloned.dfs(node => node.key, 'PRE', cloned.getNode(6), 'ITERATIVE')).toEqual([6, 3, 7]);
-    expect(cloned.dfs(node => (node ? node.key : null), 'PRE', cloned.getNode(6), 'ITERATIVE', true)).toEqual([
+    expect(cloned.dfs(node => node.key, 'PRE', false, cloned.getNode(6), 'ITERATIVE')).toEqual([6, 3, 7]);
+    expect(cloned.dfs(node => (node ? node.key : null), 'PRE', false, cloned.getNode(6), 'ITERATIVE', true)).toEqual([
       6,
       3,
       7,
       null
     ]);
-    expect(cloned.dfs(node => (node ? node.key : node), 'PRE', cloned.getNode(6), 'ITERATIVE', true)).toEqual([
+    expect(cloned.dfs(node => (node ? node.key : node), 'PRE', false, cloned.getNode(6), 'ITERATIVE', true)).toEqual([
       6,
       3,
       7,
       null
     ]);
-    expect(cloned.dfs(node => (node ? node.key : null), 'PRE', cloned.getNode(6), 'RECURSIVE', true)).toEqual([
+    expect(cloned.dfs(node => (node ? node.key : null), 'PRE', false, cloned.getNode(6), 'RECURSIVE', true)).toEqual([
       6,
       3,
       7,
@@ -532,11 +532,11 @@ describe('BinaryTree', () => {
     expect(binTree.dfs()).toEqual([]);
     expect([...binTree.values()]).toEqual([]);
     binTree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
-    expect(binTree.dfs(node => node.key, 'PRE', undefined, 'ITERATIVE')).toEqual([4, 2, 1, 5, 6, 3, 7]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'PRE', undefined, 'ITERATIVE', false)).toEqual([
-      4, 2, 1, 5, 6, 3, 7
-    ]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'PRE', undefined, 'ITERATIVE', true)).toEqual([
+    expect(binTree.dfs(node => node.key, 'PRE', false, undefined, 'ITERATIVE')).toEqual([4, 2, 1, 5, 6, 3, 7]);
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'PRE', false, undefined, 'ITERATIVE', false)).toEqual(
+      [4, 2, 1, 5, 6, 3, 7]
+    );
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'PRE', false, undefined, 'ITERATIVE', true)).toEqual([
       4,
       2,
       null,
@@ -549,11 +549,11 @@ describe('BinaryTree', () => {
       null
     ]);
 
-    expect(binTree.dfs(node => node.key, 'PRE', undefined, 'RECURSIVE')).toEqual([4, 2, 1, 5, 6, 3, 7]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'PRE', undefined, 'RECURSIVE', false)).toEqual([
-      4, 2, 1, 5, 6, 3, 7
-    ]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'PRE', undefined, 'RECURSIVE', true)).toEqual([
+    expect(binTree.dfs(node => node.key, 'PRE', false, undefined, 'RECURSIVE')).toEqual([4, 2, 1, 5, 6, 3, 7]);
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'PRE', false, undefined, 'RECURSIVE', false)).toEqual(
+      [4, 2, 1, 5, 6, 3, 7]
+    );
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'PRE', false, undefined, 'RECURSIVE', true)).toEqual([
       4,
       2,
       null,
@@ -566,11 +566,11 @@ describe('BinaryTree', () => {
       null
     ]);
 
-    expect(binTree.dfs(node => node.key, 'IN', undefined, 'ITERATIVE')).toEqual([2, 5, 1, 4, 7, 3, 6]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', undefined, 'ITERATIVE', false)).toEqual([
+    expect(binTree.dfs(node => node.key, 'IN', false, undefined, 'ITERATIVE')).toEqual([2, 5, 1, 4, 7, 3, 6]);
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', false, undefined, 'ITERATIVE', false)).toEqual([
       2, 5, 1, 4, 7, 3, 6
     ]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', undefined, 'ITERATIVE', true)).toEqual([
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', false, undefined, 'ITERATIVE', true)).toEqual([
       null,
       2,
       5,
@@ -583,11 +583,11 @@ describe('BinaryTree', () => {
       null
     ]);
 
-    expect(binTree.dfs(node => node.key, 'IN', undefined, 'RECURSIVE')).toEqual([2, 5, 1, 4, 7, 3, 6]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', undefined, 'RECURSIVE', false)).toEqual([
+    expect(binTree.dfs(node => node.key, 'IN', false, undefined, 'RECURSIVE')).toEqual([2, 5, 1, 4, 7, 3, 6]);
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', false, undefined, 'RECURSIVE', false)).toEqual([
       2, 5, 1, 4, 7, 3, 6
     ]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', undefined, 'RECURSIVE', true)).toEqual([
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', false, undefined, 'RECURSIVE', true)).toEqual([
       null,
       2,
       5,
@@ -600,89 +600,71 @@ describe('BinaryTree', () => {
       null
     ]);
 
-    expect(binTree.dfs(node => node.key, 'POST', undefined, 'ITERATIVE')).toEqual([5, 1, 2, 7, 3, 6, 4]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'POST', undefined, 'ITERATIVE', false)).toEqual([
-      5, 1, 2, 7, 3, 6, 4
-    ]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'POST', undefined, 'ITERATIVE', true)).toEqual([
-      null,
-      5,
-      null,
-      1,
-      2,
-      7,
-      3,
-      null,
-      6,
-      4
-    ]);
+    expect(binTree.dfs(node => node.key, 'POST', false, undefined, 'ITERATIVE')).toEqual([5, 1, 2, 7, 3, 6, 4]);
+    expect(
+      binTree.dfs(node => (node !== null ? node.key : null), 'POST', false, undefined, 'ITERATIVE', false)
+    ).toEqual([5, 1, 2, 7, 3, 6, 4]);
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'POST', false, undefined, 'ITERATIVE', true)).toEqual(
+      [null, 5, null, 1, 2, 7, 3, null, 6, 4]
+    );
 
-    expect(binTree.dfs(node => node.key, 'POST', undefined, 'RECURSIVE')).toEqual([5, 1, 2, 7, 3, 6, 4]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'POST', undefined, 'RECURSIVE', false)).toEqual([
-      5, 1, 2, 7, 3, 6, 4
-    ]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'POST', undefined, 'RECURSIVE', true)).toEqual([
-      null,
-      5,
-      null,
-      1,
-      2,
-      7,
-      3,
-      null,
-      6,
-      4
-    ]);
+    expect(binTree.dfs(node => node.key, 'POST', false, undefined, 'RECURSIVE')).toEqual([5, 1, 2, 7, 3, 6, 4]);
+    expect(
+      binTree.dfs(node => (node !== null ? node.key : null), 'POST', false, undefined, 'RECURSIVE', false)
+    ).toEqual([5, 1, 2, 7, 3, 6, 4]);
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'POST', false, undefined, 'RECURSIVE', true)).toEqual(
+      [null, 5, null, 1, 2, 7, 3, null, 6, 4]
+    );
   });
 
   it('should sub binTree traverse', () => {
     binTree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
-    expect(binTree.dfs(node => node.key, 'PRE', binTree.getNode(6), 'ITERATIVE')).toEqual([6, 3, 7]);
+    expect(binTree.dfs(node => node.key, 'PRE', false, binTree.getNode(6), 'ITERATIVE')).toEqual([6, 3, 7]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'PRE', binTree.getNode(6), 'ITERATIVE', false)
+      binTree.dfs(node => (node !== null ? node.key : null), 'PRE', false, binTree.getNode(6), 'ITERATIVE', false)
     ).toEqual([6, 3, 7]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'PRE', binTree.getNode(6), 'ITERATIVE', true)
+      binTree.dfs(node => (node !== null ? node.key : null), 'PRE', false, binTree.getNode(6), 'ITERATIVE', true)
     ).toEqual([6, 3, 7, null]);
 
-    expect(binTree.dfs(node => node.key, 'PRE', binTree.getNode(6), 'RECURSIVE')).toEqual([6, 3, 7]);
+    expect(binTree.dfs(node => node.key, 'PRE', false, binTree.getNode(6), 'RECURSIVE')).toEqual([6, 3, 7]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'PRE', binTree.getNode(6), 'RECURSIVE', false)
+      binTree.dfs(node => (node !== null ? node.key : null), 'PRE', false, binTree.getNode(6), 'RECURSIVE', false)
     ).toEqual([6, 3, 7]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'PRE', binTree.getNode(6), 'RECURSIVE', true)
+      binTree.dfs(node => (node !== null ? node.key : null), 'PRE', false, binTree.getNode(6), 'RECURSIVE', true)
     ).toEqual([6, 3, 7, null]);
 
-    expect(binTree.dfs(node => node.key, 'IN', binTree.getNode(6), 'ITERATIVE')).toEqual([7, 3, 6]);
+    expect(binTree.dfs(node => node.key, 'IN', false, binTree.getNode(6), 'ITERATIVE')).toEqual([7, 3, 6]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'IN', binTree.getNode(6), 'ITERATIVE', false)
+      binTree.dfs(node => (node !== null ? node.key : null), 'IN', false, binTree.getNode(6), 'ITERATIVE', false)
     ).toEqual([7, 3, 6]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', binTree.getNode(6), 'ITERATIVE', true)).toEqual(
-      [7, 3, 6, null]
-    );
+    expect(
+      binTree.dfs(node => (node !== null ? node.key : null), 'IN', false, binTree.getNode(6), 'ITERATIVE', true)
+    ).toEqual([7, 3, 6, null]);
 
-    expect(binTree.dfs(node => node.key, 'IN', binTree.getNode(6), 'RECURSIVE')).toEqual([7, 3, 6]);
+    expect(binTree.dfs(node => node.key, 'IN', false, binTree.getNode(6), 'RECURSIVE')).toEqual([7, 3, 6]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'IN', binTree.getNode(6), 'RECURSIVE', false)
+      binTree.dfs(node => (node !== null ? node.key : null), 'IN', false, binTree.getNode(6), 'RECURSIVE', false)
     ).toEqual([7, 3, 6]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', binTree.getNode(6), 'RECURSIVE', true)).toEqual(
-      [7, 3, 6, null]
-    );
+    expect(
+      binTree.dfs(node => (node !== null ? node.key : null), 'IN', false, binTree.getNode(6), 'RECURSIVE', true)
+    ).toEqual([7, 3, 6, null]);
 
-    expect(binTree.dfs(node => node.key, 'POST', binTree.getNode(6), 'ITERATIVE')).toEqual([7, 3, 6]);
+    expect(binTree.dfs(node => node.key, 'POST', false, binTree.getNode(6), 'ITERATIVE')).toEqual([7, 3, 6]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'POST', binTree.getNode(6), 'ITERATIVE', false)
+      binTree.dfs(node => (node !== null ? node.key : null), 'POST', false, binTree.getNode(6), 'ITERATIVE', false)
     ).toEqual([7, 3, 6]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'POST', binTree.getNode(6), 'ITERATIVE', true)
+      binTree.dfs(node => (node !== null ? node.key : null), 'POST', false, binTree.getNode(6), 'ITERATIVE', true)
     ).toEqual([7, 3, null, 6]);
 
-    expect(binTree.dfs(node => node.key, 'POST', binTree.getNode(6), 'RECURSIVE')).toEqual([7, 3, 6]);
+    expect(binTree.dfs(node => node.key, 'POST', false, binTree.getNode(6), 'RECURSIVE')).toEqual([7, 3, 6]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'POST', binTree.getNode(6), 'RECURSIVE', false)
+      binTree.dfs(node => (node !== null ? node.key : null), 'POST', false, binTree.getNode(6), 'RECURSIVE', false)
     ).toEqual([7, 3, 6]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'POST', binTree.getNode(6), 'RECURSIVE', true)
+      binTree.dfs(node => (node !== null ? node.key : null), 'POST', false, binTree.getNode(6), 'RECURSIVE', true)
     ).toEqual([7, 3, null, 6]);
   });
 
@@ -814,7 +796,7 @@ describe('BinaryTree Morris Traversal', () => {
 
     expect(result).toEqual(expected);
     expect(binTree.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(binTree.dfs(node => node.key, 'IN', binTree.root, 'RECURSIVE')).toEqual(expected);
+    expect(binTree.dfs(node => node.key, 'IN', false, binTree.root, 'RECURSIVE')).toEqual(expected);
   });
 
   it('should perform pre-order Morris traversal correctly as dfs traversal', () => {
@@ -875,7 +857,7 @@ describe('BinaryTree toEntryFn', () => {
 
     expect(binTree.morris(node => node.key, 'IN')).toEqual(expected);
     expect(binTree.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(binTree.dfs(node => node.key, 'IN', binTree.root, 'RECURSIVE')).toEqual(expected);
+    expect(binTree.dfs(node => node.key, 'IN', false, binTree.root, 'RECURSIVE')).toEqual(expected);
   });
 
   it('should toEntryFn with initial', () => {
@@ -890,7 +872,7 @@ describe('BinaryTree toEntryFn', () => {
 
     expect(binTree.morris(node => node.key, 'IN')).toEqual(expected);
     expect(binTree.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(binTree.dfs(node => node.key, 'IN', binTree.root, 'RECURSIVE')).toEqual(expected);
+    expect(binTree.dfs(node => node.key, 'IN', false, binTree.root, 'RECURSIVE')).toEqual(expected);
   });
 
   it('should no toEntryFn', () => {
@@ -905,7 +887,7 @@ describe('BinaryTree toEntryFn', () => {
 
     expect(binTree.morris(node => node.key, 'IN')).toEqual(data.sort((a, b) => a.obj.id - b.obj.id));
     expect(binTree.dfs(node => node.key, 'IN')).toEqual(data);
-    expect(binTree.dfs(node => node.key, 'IN', binTree.root, 'RECURSIVE')).toEqual(data);
+    expect(binTree.dfs(node => node.key, 'IN', false, binTree.root, 'RECURSIVE')).toEqual(data);
   });
 });
 
@@ -953,19 +935,21 @@ describe('BinaryTree traversals', () => {
     );
 
     expect(binTree.dfs(node => node.key, 'PRE')).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
-    expect(binTree.dfs(node => node.key, 'PRE', binTree.root, 'RECURSIVE')).toEqual([
+    expect(binTree.dfs(node => node.key, 'PRE', false, binTree.root, 'RECURSIVE')).toEqual([
       35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55
     ]);
     expect(
-      binTree.dfs(node => node, 'PRE', binTree.root, 'ITERATIVE', true).map(node => (node === null ? null : node.key))
+      binTree
+        .dfs(node => node, 'PRE', false, binTree.root, 'ITERATIVE', true)
+        .map(node => (node === null ? null : node.key))
     ).toEqual([35, 20, 15, null, 16, 29, 28, 30, 40, null, 50, 45, 55]);
     expect(
-      binTree.dfs(node => node, 'PRE', binTree.root, 'RECURSIVE', true).map(node => (node ? node.key : null))
+      binTree.dfs(node => node, 'PRE', false, binTree.root, 'RECURSIVE', true).map(node => (node ? node.key : null))
     ).toEqual([35, 20, 15, null, 16, 29, 28, 30, 40, null, 50, 45, 55]);
 
     expect(binTree.dfs(node => node.key, 'IN')).toEqual([15, 16, 20, 28, 29, 30, 35, 40, 45, 50, 55]);
     expect(binTree.dfs(node => node.key, 'POST')).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
-    expect(binTree.dfs(node => node.key, 'POST', binTree.root, 'RECURSIVE')).toEqual([
+    expect(binTree.dfs(node => node.key, 'POST', false, binTree.root, 'RECURSIVE')).toEqual([
       16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35
     ]);
     expect(binTree.bfs(node => node.key, binTree.root, 'RECURSIVE')).toEqual([
@@ -1434,3 +1418,69 @@ describe('BinaryTree not map mode iterative methods test', () => {
     expect(cloned.get(cloned.root?.right)).toBe('c');
   });
 });
+
+describe('classic use', () => {
+  it('@example determine loan approval using a decision tree', () => {
+    // Decision tree structure
+    const loanDecisionTree = new BinaryTree<string>(
+      ['stableIncome', 'goodCredit', 'Rejected', 'Approved', 'Rejected'],
+      { isDuplicate: true }
+    );
+
+    function determineLoanApproval(
+      node?: BinaryTreeNode<string> | null,
+      conditions?: { [key: string]: boolean }
+    ): string {
+      if (!node) throw new Error('Invalid node');
+
+      // If it's a leaf node, return the decision result
+      if (!node.left && !node.right) return node.key;
+
+      // Check if a valid condition exists for the current node's key
+      return conditions?.[node.key]
+        ? determineLoanApproval(node.left, conditions)
+        : determineLoanApproval(node.right, conditions);
+    }
+
+    // Test case 1: Stable income and good credit score
+    expect(determineLoanApproval(loanDecisionTree.root, { stableIncome: true, goodCredit: true })).toBe('Approved');
+
+    // Test case 2: Stable income but poor credit score
+    expect(determineLoanApproval(loanDecisionTree.root, { stableIncome: true, goodCredit: false })).toBe('Rejected');
+
+    // Test case 3: No stable income
+    expect(determineLoanApproval(loanDecisionTree.root, { stableIncome: false, goodCredit: true })).toBe('Rejected');
+
+    // Test case 4: No stable income and poor credit score
+    expect(determineLoanApproval(loanDecisionTree.root, { stableIncome: false, goodCredit: false })).toBe('Rejected');
+  });
+
+  it('@example evaluate the arithmetic expression represented by the binary tree', () => {
+    const expressionTree = new BinaryTree<number | string>(['+', 3, '*', null, null, 5, '-', null, null, 2, 8]);
+
+    function evaluate(node?: BinaryTreeNode<number | string> | null): number {
+      if (!node) return 0;
+
+      if (typeof node.key === 'number') return node.key;
+
+      const leftValue = evaluate(node.left); // Evaluate the left subtree
+      const rightValue = evaluate(node.right); // Evaluate the right subtree
+
+      // Perform the operation based on the current node's operator
+      switch (node.key) {
+        case '+':
+          return leftValue + rightValue;
+        case '-':
+          return leftValue - rightValue;
+        case '*':
+          return leftValue * rightValue;
+        case '/':
+          return rightValue !== 0 ? leftValue / rightValue : 0; // Handle division by zero
+        default:
+          throw new Error(`Unsupported operator: ${node.key}`);
+      }
+    }
+
+    expect(evaluate(expressionTree.root)).toBe(-27);
+  });
+});

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

@@ -90,7 +90,7 @@ describe('BST operations test', () => {
     expect(nodes.map(node => node.key)).toEqual([15]);
 
     let subTreeSum = 0;
-    if (node15) bst.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) bst.dfs(node => (subTreeSum += node.key), 'PRE', false, 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -299,7 +299,7 @@ describe('BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) objBST.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) objBST.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -492,7 +492,7 @@ describe('BST operations test', () => {
 
   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([4, 12])).toEqual([5, 7, 10, 12]);
     expect(() => bst.rangeSearch([12, 4])).toThrow('low must be less than or equal to high');
     expect(bst.rangeSearch([12, 12])).toEqual([12]);
   });
@@ -535,7 +535,7 @@ describe('BST operations test recursively', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) bst.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) bst.dfs(node => (subTreeSum += node.key), 'PRE', false, 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -742,7 +742,7 @@ describe('BST operations test recursively', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) objBST.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) objBST.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -1080,10 +1080,10 @@ describe('BST Performance test', function () {
   it('should dfs as sub tree traversal, null should be ignored', () => {
     const bst = new BST();
     bst.addMany([4, 2, 6, 1, 3, 5, 7]);
-    expect(bst.dfs(node => node.key, 'PRE', bst.getNode(6), 'ITERATIVE')).toEqual([6, 5, 7]);
-    expect(bst.dfs(node => node.key, 'PRE', bst.getNode(6), 'RECURSIVE')).toEqual([6, 5, 7]);
-    expect(bst.dfs(node => node?.key ?? undefined, 'PRE', bst.getNode(6), 'ITERATIVE')).toEqual([6, 5, 7]);
-    expect(bst.dfs(node => node?.key ?? undefined, 'PRE', bst.getNode(6), 'RECURSIVE')).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node.key, 'PRE', false, bst.getNode(6), 'ITERATIVE')).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node.key, 'PRE', false, bst.getNode(6), 'RECURSIVE')).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node?.key ?? undefined, 'PRE', false, bst.getNode(6), 'ITERATIVE')).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node?.key ?? undefined, 'PRE', false, bst.getNode(6), 'RECURSIVE')).toEqual([6, 5, 7]);
   });
 });
 
@@ -1565,9 +1565,9 @@ describe('classic use', () => {
   // 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.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(5, 10))).toEqual([5, 7, 10]);
+    expect(bst.rangeSearch([4, 12], node => node.key.toString())).toEqual(['5', '7', '10', '12']);
+    expect(bst.search(new Range(4, 12, true, false))).toEqual([5, 7, 10]);
     expect(bst.rangeSearch([15, 20])).toEqual([15, 18]);
     expect(bst.search(new Range(15, 20, false))).toEqual([18]);
   });