data-structure-typed 1.54.2 → 2.0.0

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

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';
 
@@ -504,11 +504,11 @@ describe('RedBlackTree 2', () => {
     expect(rbTree.isBST()).toBe(true);
     expect(rbTree.isBST(rbTree.root, 'RECURSIVE')).toBe(true);
 
-    expect(rbTree.dfs(n => n.key, 'IN', rbTree.root, 'ITERATIVE')).toEqual([
+    expect(rbTree.dfs(n => n.key, 'IN', false, rbTree.root, 'ITERATIVE')).toEqual([
       49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
       77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
     ]);
-    expect(rbTree.dfs(n => n.key, 'IN', rbTree.root, 'RECURSIVE')).toEqual([
+    expect(rbTree.dfs(n => n.key, 'IN', false, rbTree.root, 'RECURSIVE')).toEqual([
       49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
       77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
     ]);
@@ -524,7 +524,7 @@ describe('RedBlackTree 2', () => {
 
     expect(rbTree.size).toBe(0);
     expect(rbTree.isBST()).toBe(true);
-    expect(rbTree.dfs(n => n.key, 'IN', rbTree.root, 'ITERATIVE')).toEqual([]);
+    expect(rbTree.dfs(n => n.key, 'IN', false, rbTree.root, 'ITERATIVE')).toEqual([]);
 
     rbTree.clear();
     for (let i = 0; i < 1000; i++) {
@@ -838,14 +838,6 @@ describe('real world data', () => {
 });
 
 describe('classic use', () => {
-  // Test case for finding elements in a given range
-  it('@example Find elements in a range', () => {
-    const bst = new RedBlackTree<number>([10, 5, 15, 3, 7, 12, 18]);
-    expect(bst.search(new Range(5, 10))).toEqual([5, 10, 7]);
-    expect(bst.search(new Range(4, 12))).toEqual([5, 10, 12, 7]);
-    expect(bst.search(new Range(15, 20))).toEqual([15, 18]);
-  });
-
   it('@example using Red-Black Tree as a price-based index for stock data', () => {
     // Define the structure of individual stock records
     interface StockRecord {
@@ -887,6 +879,6 @@ describe('classic use', () => {
       [200, 400], // Price range
       node => priceIndex.get(node)?.symbol // Extract stock symbols for the result
     );
-    expect(stocksInRange).toEqual(['GOOGL', 'MSFT', 'META']); // Verify stocks in the range
+    expect(stocksInRange).toEqual(['GOOGL', 'META', 'MSFT']); // Verify stocks in the range
   });
 });

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

@@ -149,7 +149,7 @@ describe('TreeCounter operations test1', () => {
     expect(minNodeBySpecificNode?.key).toBe(14);
 
     let subTreeSum = 0;
-    if (node15) treeCounter.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) treeCounter.dfs(node => (subTreeSum += node.key), 'PRE', false, 15);
     expect(subTreeSum).toBe(45);
     let lesserSum = 0;
     treeCounter.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
@@ -157,7 +157,7 @@ describe('TreeCounter operations test1', () => {
 
     expect(node15 instanceof TreeCounterNode);
     if (node15 instanceof TreeCounterNode) {
-      const subTreeAdd = treeCounter.dfs(node => (node.count += 1), 'PRE', 15);
+      const subTreeAdd = treeCounter.dfs(node => (node.count += 1), 'PRE', false, 15);
       expect(subTreeAdd);
     }
     const node11 = treeCounter.getNode(11);
@@ -407,7 +407,7 @@ describe('TreeCounter operations test recursively1', () => {
     expect(minNodeBySpecificNode?.key).toBe(14);
 
     let subTreeSum = 0;
-    if (node15) treeCounter.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) treeCounter.dfs(node => (subTreeSum += node.key), 'PRE', false, 15);
     expect(subTreeSum).toBe(45);
     let lesserSum = 0;
     expect(treeCounter.has(9)).toBe(true);
@@ -423,7 +423,7 @@ describe('TreeCounter operations test recursively1', () => {
 
     expect(node15 instanceof TreeCounterNode);
     if (node15 instanceof TreeCounterNode) {
-      const subTreeAdd = treeCounter.dfs(node => (node.count += 1), 'PRE', 15);
+      const subTreeAdd = treeCounter.dfs(node => (node.count += 1), 'PRE', false, 15);
       expect(subTreeAdd);
     }
     const node11 = treeCounter.getNode(11);

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';
@@ -519,11 +519,11 @@ describe('TreeMultiMap 2', () => {
     expect(tmm.isBST()).toBe(true);
     expect(tmm.isBST(tmm.root, 'RECURSIVE')).toBe(true);
 
-    expect(tmm.dfs(n => n.key, 'IN', tmm.root, 'ITERATIVE')).toEqual([
+    expect(tmm.dfs(n => n.key, 'IN', false, tmm.root, 'ITERATIVE')).toEqual([
       49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
       77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
     ]);
-    expect(tmm.dfs(n => n.key, 'IN', tmm.root, 'RECURSIVE')).toEqual([
+    expect(tmm.dfs(n => n.key, 'IN', false, tmm.root, 'RECURSIVE')).toEqual([
       49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
       77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
     ]);
@@ -539,7 +539,7 @@ describe('TreeMultiMap 2', () => {
 
     expect(tmm.size).toBe(0);
     expect(tmm.isBST()).toBe(true);
-    expect(tmm.dfs(n => n.key, 'IN', tmm.root, 'ITERATIVE')).toEqual([]);
+    expect(tmm.dfs(n => n.key, 'IN', false, tmm.root, 'ITERATIVE')).toEqual([]);
 
     tmm.clear();
     for (let i = 0; i < 1000; i++) {
@@ -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, 10, 7]);
-    expect(tmm.search(new Range(4, 12))).toEqual([5, 10, 12, 7]);
-    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/linked-list/doubly-linked-list.test.ts

@@ -32,14 +32,14 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should deleteAt', () => {
-    expect(list.deleteAt(1)).toBe(true);
-    expect(list.deleteAt(-1)).toBe(false);
-    expect(list.deleteAt(list.size)).toBe(false);
-    expect(list.size).toBe(4);
-    expect(list.deleteAt(4)).toBe(false);
+    expect(list.deleteAt(1)).toBe(2);
+    expect(list.deleteAt(-1)).toBe(undefined);
+    expect(list.deleteAt(list.length)).toBe(undefined);
+    expect(list.length).toBe(4);
+    expect(list.deleteAt(4)).toBe(undefined);
     expect([...list]).toEqual([1, 3, 4, 5]);
     expect(list.isEmpty()).toBe(false);
-    expect(list.deleteAt(3)).toBe(true);
+    expect(list.deleteAt(3)).toBe(5);
     expect([...list]).toEqual([1, 3, 4]);
   });
 
@@ -103,7 +103,7 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should initialize an empty list', () => {
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -119,17 +119,36 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(1);
     list.push(2);
     list.push(3);
-    expect(list.size).toBe(3);
+    expect(list.length).toBe(3);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(3);
   });
 
+  it('push with maxLen', () => {
+    const list = new DoublyLinkedList<number>([], { maxLen: 10 });
+    for (let i = 0; i < 1000; i++) {
+      list.push(i);
+    }
+    expect(list.maxLen).toBe(10);
+    expect(list.length).toBe(10);
+    expect(list.first).toBe(990);
+
+    list.clear();
+    for (let i = 0; i < 1000; i++) {
+      list.unshift(i);
+    }
+
+    expect(list.maxLen).toBe(10);
+    expect(list.length).toBe(10);
+    expect(list.last).toBe(990);
+  });
+
   it('should pop elements from the end of the list', () => {
     list.push(1);
     list.push(2);
     const poppedValue = list.pop();
     expect(poppedValue).toBe(2);
-    expect(list.size).toBe(1);
+    expect(list.length).toBe(1);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(1);
     list.pop();
@@ -145,19 +164,19 @@ describe('DoublyLinkedList Operation Test', () => {
 
     // Inserting at the beginning
     list.addAt(0, 0);
-    expect(list.size).toBe(4);
+    expect(list.length).toBe(4);
     expect(list.at(0)).toBe(0);
     expect(list.at(1)).toBe(1);
 
     // Inserting in the middle
     list.addAt(2, 1.5);
-    expect(list.size).toBe(5);
+    expect(list.length).toBe(5);
     expect(list.at(2)).toBe(1.5);
     expect(list.at(3)).toBe(2);
 
     // Inserting at the end
     list.addAt(5, 4);
-    expect(list.size).toBe(6);
+    expect(list.length).toBe(6);
     expect(list.at(5)).toBe(4);
     expect(list.tail!.value).toBe(4);
     expect(list.at(-1)).toBe(undefined);
@@ -171,18 +190,18 @@ describe('DoublyLinkedList Operation Test', () => {
 
     // Deleting from the beginning
     const deletedValue = list.deleteAt(0);
-    expect(deletedValue).toBe(true);
-    expect(list.size).toBe(2);
+    expect(deletedValue).toBe(1);
+    expect(list.length).toBe(2);
     expect(list.head!.value).toBe(2);
 
     // Deleting from the middle
     list.deleteAt(0); // Deleting the second element
-    expect(list.size).toBe(1);
+    expect(list.length).toBe(1);
     expect(list.head!.value).toBe(3);
 
     // Deleting from the end
     list.deleteAt(0);
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -193,16 +212,16 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
 
     list.delete(2);
-    expect(list.size).toBe(2);
+    expect(list.length).toBe(2);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(3);
 
     list.delete(1);
-    expect(list.size).toBe(1);
+    expect(list.length).toBe(1);
     expect(list.head!.value).toBe(3);
 
     list.delete(3);
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -307,7 +326,7 @@ describe('DoublyLinkedList Operation Test', () => {
 
     list.clear();
 
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -447,6 +466,95 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 });
 
+describe('DoublyLinkedList Additional Methods', () => {
+  // Slice method implementation and test
+  test('slice should return a new list with specified range', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 4, 5]);
+    const slicedList = list.slice(1, 4);
+
+    expect(slicedList.toArray()).toEqual([2, 3, 4]);
+    expect(list.length).toBe(5); // Original list unchanged
+  });
+
+  // Splice method implementation
+  test('splice should modify list and return removed elements', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 4, 5]);
+    const removedList = list.splice(2, 2, 6, 7);
+
+    expect(list.toArray()).toEqual([1, 2, 6, 7, 5]);
+    expect(removedList.toArray()).toEqual([3, 4]);
+  });
+
+  // Concat method test
+  test('concat should combine multiple lists', () => {
+    const list1 = new DoublyLinkedList([1, 2]);
+    const list2 = new DoublyLinkedList([3, 4]);
+    const list3 = new DoublyLinkedList([5, 6]);
+
+    const concatenatedList = list1.concat(list2, list3);
+    expect(concatenatedList.toArray()).toEqual([1, 2, 3, 4, 5, 6]);
+  });
+
+  // Sort method test
+  test('sort should order elements in ascending order', () => {
+    const list = new DoublyLinkedList([5, 2, 8, 1, 9]);
+    list.sort((a, b) => a - b);
+
+    expect(list.toArray()).toEqual([1, 2, 5, 8, 9]);
+  });
+
+  // Reverse method test
+  test('reverse should invert the list order', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 4, 5]);
+    list.reverse();
+
+    expect(list.toArray()).toEqual([5, 4, 3, 2, 1]);
+  });
+
+  // Join method test
+  test('join should convert list to string with separator', () => {
+    const list = new DoublyLinkedList(['a', 'b', 'c']);
+
+    expect(list.join('-')).toBe('a-b-c');
+    expect(list.join()).toBe('a,b,c');
+  });
+
+  // IndexOf method test
+  test('indexOf should return first occurrence index', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+
+    expect(list.indexOf(2)).toBe(1);
+    expect(list.indexOf(4)).toBe(-1);
+  });
+
+  // LastIndexOf method test
+  test('lastIndexOf should return last occurrence index', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+
+    expect(list.lastIndexOf(2)).toBe(3);
+    expect(list.lastIndexOf(4)).toBe(-1);
+  });
+
+  // findIndex method test
+  test('findIndex should return first occurrence index', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect(list.findIndex(item => item === 2)).toBe(1);
+    expect(list.findIndex(item => item === 4)).toBe(-1);
+  });
+
+  // fill method test
+  test('fill should return fill all the list', () => {
+    let list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9)]).toEqual([9, 9, 9, 9, 9]);
+    list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, 2, 3)]).toEqual([1, 2, 9, 2, 1]);
+    list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -3, -2)]).toEqual([1, 2, 9, 2, 1]);
+    list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -2, -3)]).toEqual([1, 2, 3, 2, 1]);
+  });
+});
+
 describe('iterable methods', () => {
   it('should forEach, some, every, filter, map, reduce of the deque', () => {
     const dl = new DoublyLinkedList<number>();
@@ -578,7 +686,7 @@ describe('classic use', () => {
         const initialNode = this.currentSong;
 
         // Loop through the playlist twice
-        for (let i = 0; i < this.playlist.size * 2; i++) {
+        for (let i = 0; i < this.playlist.length * 2; i++) {
           playedSongs.push(this.currentSong!.value);
           this.currentSong = this.currentSong!.next || this.playlist.head; // Loop back to the start if needed
         }
@@ -700,7 +808,7 @@ describe('classic use', () => {
         }
 
         // Check capacity
-        if (this.list.size >= this.capacity) {
+        if (this.list.length >= this.capacity) {
           // Delete the least recently used element (the tail of the linked list)
           const removedNode = this.list.tail;
           if (removedNode) {
@@ -745,9 +853,9 @@ describe('classic use', () => {
         this.map.clear();
       }
 
-      // Get the current cache size
-      get size(): number {
-        return this.list.size;
+      // Get the current cache length
+      get length(): number {
+        return this.list.length;
       }
 
       // Check if it is empty
@@ -806,7 +914,7 @@ describe('classic use', () => {
 
     expect(cache.delete('a')).toBe(true);
     expect(cache.get('a')).toBeUndefined();
-    expect(cache.size).toBe(1);
+    expect(cache.length).toBe(1);
 
     // Should support clearing cache
     cache.clear();
@@ -814,7 +922,7 @@ describe('classic use', () => {
     cache.set('b', 2);
     cache.clear();
 
-    expect(cache.size).toBe(0);
+    expect(cache.length).toBe(0);
     expect(cache.isEmpty).toBe(true);
   });