data-structure-typed 1.54.3 → 2.0.1

package/src/types/data-structures/queue/queue.ts

@@ -1,5 +1,5 @@
-import { IterableElementBaseOptions } from '../base';
+import { LinearBaseOptions } from '../base';
 
-export type QueueOptions<E, R> = IterableElementBaseOptions<E, R> & {
+export type QueueOptions<E, R> = LinearBaseOptions<E, R> & {
   autoCompactRatio?: number;
 };

package/test/integration/all-in-one.test.ts

@@ -23,7 +23,7 @@ describe('AVL Tree Test from data-structure-typed', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) tree.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) tree.dfs(node => (subTreeSum += node.key), 'PRE', false, 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;

package/test/integration/avl-tree.test.ts

@@ -40,7 +40,7 @@ describe('AVL Tree Test', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) tree.dfs(node => (subTreeSum += node.key), 'IN', 15);
+    if (node15) tree.dfs(node => (subTreeSum += node.key), 'IN', false, 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;

package/test/integration/bst.test.ts

@@ -37,7 +37,7 @@ describe('Individual package BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(14);
 
     let subTreeSum = 0;
-    if (node15) bst.dfs(node => (subTreeSum += node.key), 'IN', 15);
+    if (node15) bst.dfs(node => (subTreeSum += node.key), 'IN', false, 15);
     expect(subTreeSum).toBe(45);
 
     let lesserSum = 0;
@@ -236,7 +236,7 @@ describe('Individual package BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(14);
 
     let subTreeSum = 0;
-    if (node15) objBST.dfs(node => (subTreeSum += node.key), 'IN', node15);
+    if (node15) objBST.dfs(node => (subTreeSum += node.key), 'IN', false, node15);
     expect(subTreeSum).toBe(45);
 
     let lesserSum = 0;

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

@@ -570,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

@@ -1,4 +1,4 @@
-import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode, Range } from '../../../../src';
+import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode } from '../../../../src';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
@@ -546,6 +546,7 @@ describe('AVLTree iterative methods not map mode', () => {
 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[] = [
@@ -594,18 +595,18 @@ describe('classic use', () => {
       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 }
-          ]);
+    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/red-black-tree.test.ts

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BSTNode, Range, RedBlackTree, RedBlackTreeNode } from '../../../../src';
+import { BinaryTreeNode, BSTNode, RedBlackTree, RedBlackTreeNode } from '../../../../src';
 import { getRandomInt, getRandomIntArray, magnitude } from '../../../utils';
 import { OrderedMap } from 'js-sdsl';
 

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

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BSTNode, Range, TreeMultiMap, TreeMultiMapNode } from '../../../../src';
+import { BinaryTreeNode, BSTNode, TreeMultiMap, TreeMultiMapNode } from '../../../../src';
 import { getRandomInt } from '../../../utils';
 
 import { isDebugTest } from '../../../config';
@@ -837,11 +837,169 @@ describe('real world data', () => {
 });
 
 describe('classic use', () => {
-  // Test case for finding elements in a given range
-  it('@example Find elements in a range', () => {
-    const tmm = new TreeMultiMap<number>([10, 5, 15, 3, 7, 12, 18]);
-    expect(tmm.search(new Range(5, 10))).toEqual([5, 7, 10]);
-    expect(tmm.search(new Range(4, 12))).toEqual([5, 7, 10, 12]);
-    expect(tmm.search(new Range(15, 20))).toEqual([15, 18]);
+  // Test suite for TreeMultiMap with player ranking and equipment
+  it('@example 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 TreeMultiMap<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/graph/directed-graph.test.ts

@@ -341,9 +341,9 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
     expect(distMap.get(vertex3)).toBe(35);
     expect(distMap.get(vertex4)).toBe(14);
     expect(distMap.get(vertex5)).toBe(70);
-    expect(distMap.get(vertex6)).toBe(Infinity);
+    expect(distMap.get(vertex6)).toBe(Number.MAX_SAFE_INTEGER);
     expect(distMap.get(vertex7)).toBe(61);
-    expect(distMap.get(vertex8)).toBe(Infinity);
+    expect(distMap.get(vertex8)).toBe(Number.MAX_SAFE_INTEGER);
     expect(distMap.get(vertex9)).toBe(19);
 
     expect(preMap).toBeInstanceOf(Map);
@@ -351,7 +351,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
 
     expect(paths).toBeInstanceOf(Array);
     expect(paths.length).toBe(0);
-    expect(min).toBe(Infinity);
+    expect(min).toBe(Number.MAX_SAFE_INTEGER);
     expect(minPath).toBeInstanceOf(Array);
 
     const floydResult = myGraph.floydWarshall();
@@ -360,35 +360,35 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
       const { costs, predecessor } = floydResult;
       expect(costs).toBeInstanceOf(Array);
       expect(costs.length).toBe(9);
-      expect(costs[0]).toEqual([32, 12, 35, 14, 70, Infinity, 61, Infinity, 19]);
-      expect(costs[1]).toEqual([20, 32, 23, 34, 58, Infinity, 81, Infinity, 39]);
-      expect(costs[2]).toEqual([3, 15, 38, 17, 35, Infinity, 64, Infinity, 22]);
-      expect(costs[3]).toEqual([123, 135, 120, 137, 155, Infinity, 47, Infinity, 126]);
-      expect(costs[4]).toEqual([133, 145, 130, 147, 165, Infinity, 57, Infinity, 136]);
+      expect(costs[0]).toEqual([32, 12, 35, 14, 70, Number.MAX_SAFE_INTEGER, 61, Number.MAX_SAFE_INTEGER, 19]);
+      expect(costs[1]).toEqual([20, 32, 23, 34, 58, Number.MAX_SAFE_INTEGER, 81, Number.MAX_SAFE_INTEGER, 39]);
+      expect(costs[2]).toEqual([3, 15, 38, 17, 35, Number.MAX_SAFE_INTEGER, 64, Number.MAX_SAFE_INTEGER, 22]);
+      expect(costs[3]).toEqual([123, 135, 120, 137, 155, Number.MAX_SAFE_INTEGER, 47, Number.MAX_SAFE_INTEGER, 126]);
+      expect(costs[4]).toEqual([133, 145, 130, 147, 165, Number.MAX_SAFE_INTEGER, 57, Number.MAX_SAFE_INTEGER, 136]);
       expect(costs[5]).toEqual([
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity
+        Number.MAX_SAFE_INTEGER,
+        Number.MAX_SAFE_INTEGER,
+        Number.MAX_SAFE_INTEGER,
+        Number.MAX_SAFE_INTEGER,
+        Number.MAX_SAFE_INTEGER,
+        Number.MAX_SAFE_INTEGER,
+        Number.MAX_SAFE_INTEGER,
+        Number.MAX_SAFE_INTEGER,
+        Number.MAX_SAFE_INTEGER
       ]);
-      expect(costs[6]).toEqual([76, 88, 73, 90, 108, Infinity, 137, Infinity, 79]);
+      expect(costs[6]).toEqual([76, 88, 73, 90, 108, Number.MAX_SAFE_INTEGER, 137, Number.MAX_SAFE_INTEGER, 79]);
       expect(costs[7]).toEqual([
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity,
-        Infinity
+        Number.MAX_SAFE_INTEGER,
+        Number.MAX_SAFE_INTEGER,
+        Number.MAX_SAFE_INTEGER,
+        Number.MAX_SAFE_INTEGER,
+        Number.MAX_SAFE_INTEGER,
+        Number.MAX_SAFE_INTEGER,
+        Number.MAX_SAFE_INTEGER,
+        Number.MAX_SAFE_INTEGER,
+        Number.MAX_SAFE_INTEGER
       ]);
-      expect(costs[8]).toEqual([173, 185, 170, 187, 205, Infinity, 97, Infinity, 176]);
+      expect(costs[8]).toEqual([173, 185, 170, 187, 205, Number.MAX_SAFE_INTEGER, 97, Number.MAX_SAFE_INTEGER, 176]);
 
       expect(predecessor).toBeInstanceOf(Array);
       expect(predecessor.length).toBe(9);
@@ -458,12 +458,12 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
       expect(distMap.size).toBe(9);
       expect(distMap.get(vertex1)).toBe(0);
       expect(distMap.get(vertex2)).toBe(12);
-      expect(distMap.get(vertex3)).toBe(Infinity);
+      expect(distMap.get(vertex3)).toBe(Number.MAX_SAFE_INTEGER);
       expect(distMap.get(vertex4)).toBe(14);
-      expect(distMap.get(vertex5)).toBe(Infinity);
-      expect(distMap.get(vertex6)).toBe(Infinity);
-      expect(distMap.get(vertex7)).toBe(Infinity);
-      expect(distMap.get(vertex8)).toBe(Infinity);
+      expect(distMap.get(vertex5)).toBe(Number.MAX_SAFE_INTEGER);
+      expect(distMap.get(vertex6)).toBe(Number.MAX_SAFE_INTEGER);
+      expect(distMap.get(vertex7)).toBe(Number.MAX_SAFE_INTEGER);
+      expect(distMap.get(vertex8)).toBe(Number.MAX_SAFE_INTEGER);
       expect(distMap.get(vertex9)).toBe(19);
 
       expect(minDist).toBe(12);
@@ -512,9 +512,9 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
       expect(distMap.get(vertex3)).toBe(35);
       expect(distMap.get(vertex4)).toBe(14);
       expect(distMap.get(vertex5)).toBe(70);
-      expect(distMap.get(vertex6)).toBe(Infinity);
+      expect(distMap.get(vertex6)).toBe(Number.MAX_SAFE_INTEGER);
       expect(distMap.get(vertex7)).toBe(61);
-      expect(distMap.get(vertex8)).toBe(Infinity);
+      expect(distMap.get(vertex8)).toBe(Number.MAX_SAFE_INTEGER);
       expect(distMap.get(vertex9)).toBe(19);
 
       expect(minDist).toBe(12);
@@ -574,9 +574,9 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
       expect(distMap.get(vertex3)).toBe(35);
       expect(distMap.get(vertex4)).toBe(14);
       expect(distMap.get(vertex5)).toBe(70);
-      expect(distMap.get(vertex6)).toBe(Infinity);
+      expect(distMap.get(vertex6)).toBe(Number.MAX_SAFE_INTEGER);
       expect(distMap.get(vertex7)).toBe(61);
-      expect(distMap.get(vertex8)).toBe(Infinity);
+      expect(distMap.get(vertex8)).toBe(Number.MAX_SAFE_INTEGER);
       expect(distMap.get(vertex9)).toBe(19);
 
       expect(minDist).toBe(12);

package/test/unit/data-structures/graph/undirected-graph.test.ts

@@ -264,7 +264,7 @@ describe('cycles, strongly connected components, bridges, articular points in Un
   expect(lowMap.size).toBe(8);
 });
 
-it('Should return Infinity if dest is not found', () => {
+it('Should return Number.MAX_SAFE_INTEGER if dest is not found', () => {
   const graph = new UndirectedGraph<string>();
 
   for (let i = 0; i < 3; ++i) {
@@ -274,7 +274,7 @@ it('Should return Infinity if dest is not found', () => {
   graph.addEdge(0, 1, 1);
 
   const minCost02 = graph.getMinCostBetween(0, 2, true);
-  expect(minCost02).toBe(Infinity);
+  expect(minCost02).toBe(Number.MAX_SAFE_INTEGER);
 
   const minCost01 = graph.getMinCostBetween(0, 1, true);
   expect(minCost01).toBe(1);