data-structure-typed 1.54.2 → 2.0.0

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;
@@ -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;
@@ -571,3 +570,171 @@ describe('AVLTreeMultiMap iterative methods not map mode', () => {
     expect(cloned.get(cloned.root?.right?.key)).toEqual(['c']);
   });
 });
+
+describe('classic use', () => {
+  // Test suite for TreeMultiMap with player ranking and equipment
+  it('players ranked by score with their equipment', () => {
+    type Equipment = {
+      name: string; // Equipment name
+      quality: 'legendary' | 'epic' | 'rare' | 'common';
+      level: number;
+    };
+
+    type Player = {
+      name: string;
+      score: number;
+      equipments: Equipment[];
+    };
+
+    // Mock player data with their scores and equipment
+    const players: Player[] = [
+      {
+        name: 'DragonSlayer',
+        score: 8750,
+        equipments: [
+          { name: 'AWM', quality: 'legendary', level: 85 },
+          { name: 'Level 3 Helmet', quality: 'epic', level: 80 },
+          { name: 'Extended Quickdraw Mag', quality: 'rare', level: 75 },
+          { name: 'Compensator', quality: 'epic', level: 78 },
+          { name: 'Vertical Grip', quality: 'rare', level: 72 }
+        ]
+      },
+      {
+        name: 'ShadowNinja',
+        score: 7200,
+        equipments: [
+          { name: 'M416', quality: 'epic', level: 75 },
+          { name: 'Ghillie Suit', quality: 'rare', level: 70 },
+          { name: 'Red Dot Sight', quality: 'common', level: 65 },
+          { name: 'Extended QuickDraw Mag', quality: 'rare', level: 68 }
+        ]
+      },
+      {
+        name: 'RuneMaster',
+        score: 9100,
+        equipments: [
+          { name: 'KAR98K', quality: 'legendary', level: 90 },
+          { name: 'Level 3 Vest', quality: 'legendary', level: 85 },
+          { name: 'Holographic Sight', quality: 'epic', level: 82 },
+          { name: 'Suppressor', quality: 'legendary', level: 88 },
+          { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
+        ]
+      },
+      {
+        name: 'BattleKing',
+        score: 8500,
+        equipments: [
+          { name: 'AUG', quality: 'epic', level: 82 },
+          { name: 'Red Dot Sight', quality: 'rare', level: 75 },
+          { name: 'Extended Mag', quality: 'common', level: 70 },
+          { name: 'Tactical Stock', quality: 'rare', level: 76 }
+        ]
+      },
+      {
+        name: 'SniperElite',
+        score: 7800,
+        equipments: [
+          { name: 'M24', quality: 'legendary', level: 88 },
+          { name: 'Compensator', quality: 'epic', level: 80 },
+          { name: 'Scope 8x', quality: 'legendary', level: 85 },
+          { name: 'Level 2 Helmet', quality: 'rare', level: 75 }
+        ]
+      },
+      {
+        name: 'RushMaster',
+        score: 7500,
+        equipments: [
+          { name: 'Vector', quality: 'rare', level: 72 },
+          { name: 'Level 2 Helmet', quality: 'common', level: 65 },
+          { name: 'Quickdraw Mag', quality: 'common', level: 60 },
+          { name: 'Laser Sight', quality: 'rare', level: 68 }
+        ]
+      },
+      {
+        name: 'GhostWarrior',
+        score: 8200,
+        equipments: [
+          { name: 'SCAR-L', quality: 'epic', level: 78 },
+          { name: 'Extended Quickdraw Mag', quality: 'rare', level: 70 },
+          { name: 'Holographic Sight', quality: 'epic', level: 75 },
+          { name: 'Suppressor', quality: 'rare', level: 72 },
+          { name: 'Vertical Grip', quality: 'common', level: 65 }
+        ]
+      },
+      {
+        name: 'DeathDealer',
+        score: 7300,
+        equipments: [
+          { name: 'SKS', quality: 'epic', level: 76 },
+          { name: 'Holographic Sight', quality: 'rare', level: 68 },
+          { name: 'Extended Mag', quality: 'common', level: 65 }
+        ]
+      },
+      {
+        name: 'StormRider',
+        score: 8900,
+        equipments: [
+          { name: 'MK14', quality: 'legendary', level: 92 },
+          { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
+          { name: 'Scope 8x', quality: 'epic', level: 80 },
+          { name: 'Suppressor', quality: 'legendary', level: 88 },
+          { name: 'Tactical Stock', quality: 'rare', level: 75 }
+        ]
+      },
+      {
+        name: 'CombatLegend',
+        score: 7600,
+        equipments: [
+          { name: 'UMP45', quality: 'rare', level: 74 },
+          { name: 'Level 2 Vest', quality: 'common', level: 67 },
+          { name: 'Red Dot Sight', quality: 'common', level: 62 },
+          { name: 'Extended Mag', quality: 'rare', level: 70 }
+        ]
+      }
+    ];
+
+    // Create a TreeMultiMap for player rankings
+    const playerRankings = new AVLTreeMultiMap<number, Equipment, Player>(players, {
+      toEntryFn: ({ score, equipments }) => [score, equipments],
+      isMapMode: false
+    });
+
+    const topPlayersEquipments = playerRankings.rangeSearch([8900, 10000], node => playerRankings.get(node));
+    expect(topPlayersEquipments).toEqual([
+      [
+        {
+          name: 'MK14',
+          quality: 'legendary',
+          level: 92
+        },
+        { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
+        {
+          name: 'Scope 8x',
+          quality: 'epic',
+          level: 80
+        },
+        { name: 'Suppressor', quality: 'legendary', level: 88 },
+        {
+          name: 'Tactical Stock',
+          quality: 'rare',
+          level: 75
+        }
+      ],
+      [
+        { name: 'KAR98K', quality: 'legendary', level: 90 },
+        {
+          name: 'Level 3 Vest',
+          quality: 'legendary',
+          level: 85
+        },
+        { name: 'Holographic Sight', quality: 'epic', level: 82 },
+        {
+          name: 'Suppressor',
+          quality: 'legendary',
+          level: 88
+        },
+        { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
+      ]
+    ]);
+  });
+});

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

@@ -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,71 @@ 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', () => {
+    // In interval queries, AVL trees, with their strictly balanced structure and lower height, offer better query efficiency, making them ideal for frequent and high-performance interval queries. In contrast, Red-Black trees, with lower update costs, are more suitable for scenarios involving frequent insertions and deletions where the requirements for interval queries are less demanding.
+    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);
+  });
+});