data-structure-typed 1.39.4 → 1.39.6

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

@@ -92,52 +92,65 @@ describe('DirectedGraph Operation Test', () => {
   });
 });
 
-class MyVertex<V extends string> extends DirectedVertex<V> {
-  constructor(key: VertexKey, val?: V) {
-    super(key, val);
-    this._data = val;
+class MyVertex<V = any> extends DirectedVertex<V> {
+  constructor(key: VertexKey, value?: V) {
+    super(key, value);
+    this._data = value;
   }
 
-  private _data: string | undefined;
+  private _data: V | undefined;
 
-  get data(): string | undefined {
+  get data(): V | undefined {
     return this._data;
   }
 
-  set data(value: string | undefined) {
+  set data(value: V | undefined) {
     this._data = value;
   }
 }
 
-class MyEdge<E extends string> extends DirectedEdge<E> {
-  constructor(v1: VertexKey, v2: VertexKey, weight?: number, val?: E) {
-    super(v1, v2, weight, val);
-    this._data = val;
+class MyEdge<E = any> extends DirectedEdge<E> {
+  constructor(v1: VertexKey, v2: VertexKey, weight?: number, value?: E) {
+    super(v1, v2, weight, value);
+    this._data = value;
   }
 
-  private _data: string | undefined;
+  private _data: E | undefined;
 
-  get data(): string | undefined {
+  get data(): E | undefined {
     return this._data;
   }
 
-  set data(value: string | undefined) {
+  set data(value: E | undefined) {
     this._data = value;
   }
 }
 
-class MyDirectedGraph<V extends MyVertex<string>, E extends MyEdge<string>> extends DirectedGraph<V, E> {
-  createVertex(key: VertexKey, val: V['val']): V {
-    return new MyVertex(key, val) as V;
+class MyDirectedGraph<
+  V = any,
+  E = any,
+  VO extends MyVertex<V> = MyVertex<V>,
+  EO extends MyEdge<E> = MyEdge<E>
+> extends DirectedGraph<V, E, VO, EO> {
+  createVertex(key: VertexKey, value: V): VO {
+    return new MyVertex(key, value) as VO;
+  }
+
+  createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO {
+    return new MyEdge(src, dest, weight ?? 1, value) as EO;
+  }
+
+  setInEdgeMap(value: Map<VO, EO[]>) {
+    super._setInEdgeMap(value);
   }
 
-  createEdge(src: VertexKey, dest: VertexKey, weight?: number, val?: E['val']): E {
-    return new MyEdge(src, dest, weight ?? 1, val) as E;
+  setOutEdgeMap(value: Map<VO, EO[]>) {
+    super._setOutEdgeMap(value);
   }
 }
 
 describe('Inherit from DirectedGraph and perform operations', () => {
-  let myGraph = new MyDirectedGraph<MyVertex<string>, MyEdge<string>>();
+  let myGraph = new MyDirectedGraph<string, string>();
   beforeEach(() => {
     myGraph = new MyDirectedGraph();
   });
@@ -159,6 +172,8 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     myGraph.addVertex(2, 'data2');
     myGraph.addEdge(1, 2, 10, 'edge-data1-2');
     myGraph.addEdge(new MyEdge(2, 1, 20, 'edge-data2-1'));
+    myGraph.setInEdgeMap(myGraph.inEdgeMap);
+    myGraph.setOutEdgeMap(myGraph.outEdgeMap);
 
     expect(myGraph.edgeSet().length).toBe(2);
     // TODO
@@ -177,7 +192,7 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     expect(edge1).toBeInstanceOf(MyEdge);
     if (edge1) {
       expect(edge1.data).toBe('val1');
-      expect(edge1?.val).toBe('val1');
+      expect(edge1?.value).toBe('val1');
       expect(edge1).toBeInstanceOf(MyEdge);
       expect(edge1.src).toBe(1);
       expect(edge1).toEqual(edge2);
@@ -199,7 +214,7 @@ describe('Inherit from DirectedGraph and perform operations', () => {
 
     expect(removedEdge).toBeInstanceOf(MyEdge);
     if (removedEdge) {
-      removedEdge && expect(removedEdge.val).toBe('edge-data1-2');
+      removedEdge && expect(removedEdge.value).toBe('edge-data1-2');
       removedEdge && expect(removedEdge.src).toBe(1);
     }
     expect(edgeAfterRemoval).toBeNull();
@@ -234,7 +249,7 @@ describe('Inherit from DirectedGraph and perform operations', () => {
 });
 
 describe('Inherit from DirectedGraph and perform operations test2.', () => {
-  const myGraph = new MyDirectedGraph<MyVertex<string>, MyEdge<string>>();
+  const myGraph = new MyDirectedGraph<string, string>();
 
   it('should test graph operations', () => {
     const vertex1 = new MyVertex(1, 'data1');

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

@@ -4,17 +4,17 @@ describe('MapGraph Operation Test', () => {
   it('dijkstra shortest path', () => {
     const mapGraph = new MapGraph([5.500338, 100.173665]);
 
-    mapGraph.addVertex(new MapVertex('Surin', 5.466724, 100.274805));
-    mapGraph.addVertex(new MapVertex('Batu Feringgi Beach', 5.475141, 100.27667));
-    mapGraph.addVertex(new MapVertex('Lotus', 5.459044, 100.308767));
-    mapGraph.addVertex(new MapVertex('The Breeza', 5.454197, 100.307859));
-    mapGraph.addVertex(new MapVertex('Hard Rock Hotel', 5.46785, 100.241876));
-    mapGraph.addVertex(new MapVertex('Mira', 5.456749, 100.28665));
-    mapGraph.addVertex(new MapVertex('Penang Bible Church', 5.428683, 100.314825));
-    mapGraph.addVertex(new MapVertex('Queensbay', 5.33276, 100.306651));
-    mapGraph.addVertex(new MapVertex('Saanen Goat Farm', 5.405738, 100.207699));
-    mapGraph.addVertex(new MapVertex('Trinity Auto', 5.401126, 100.303739));
-    mapGraph.addVertex(new MapVertex('Penang Airport', 5.293185, 100.265772));
+    mapGraph.addVertex(new MapVertex('Surin', '', 5.466724, 100.274805));
+    mapGraph.addVertex(new MapVertex('Batu Feringgi Beach', '', 5.475141, 100.27667));
+    mapGraph.addVertex(new MapVertex('Lotus', '', 5.459044, 100.308767));
+    mapGraph.addVertex(new MapVertex('The Breeza', '', 5.454197, 100.307859));
+    mapGraph.addVertex(new MapVertex('Hard Rock Hotel', '', 5.46785, 100.241876));
+    mapGraph.addVertex(new MapVertex('Mira', '', 5.456749, 100.28665));
+    mapGraph.addVertex(new MapVertex('Penang Bible Church', '', 5.428683, 100.314825));
+    mapGraph.addVertex(new MapVertex('Queensbay', '', 5.33276, 100.306651));
+    mapGraph.addVertex(new MapVertex('Saanen Goat Farm', '', 5.405738, 100.207699));
+    mapGraph.addVertex(new MapVertex('Trinity Auto', '', 5.401126, 100.303739));
+    mapGraph.addVertex(new MapVertex('Penang Airport', '', 5.293185, 100.265772));
     mapGraph.addEdge('Surin', 'Lotus', 4.7);
     mapGraph.addEdge('Lotus', 'The Breeza', 1);
     mapGraph.addEdge('Batu Feringgi Beach', 'Hard Rock Hotel', 5.2);
@@ -45,17 +45,17 @@ describe('MapGraph Operation Test', () => {
 });
 
 describe('MapGraph', () => {
-  let mapGraph: MapGraph;
+  let mapGraph: MapGraph<string, string>;
 
   beforeEach(() => {
     // Create a new MapGraph instance before each test
-    mapGraph = new MapGraph([0, 0], [100, 100]);
+    mapGraph = new MapGraph<string, string>([0, 0], [100, 100]);
   });
 
   // Test adding vertices to the graph
   it('should add vertices to the graph', () => {
-    const locationA = new MapVertex('A', 10, 20, 'Location A');
-    const locationB = new MapVertex('B', 30, 40, 'Location B');
+    const locationA = new MapVertex('A', 'Location A', 10, 20);
+    const locationB = new MapVertex('B', 'Location B', 30, 40);
 
     mapGraph.addVertex(locationA);
     mapGraph.addVertex(locationB);
@@ -66,8 +66,8 @@ describe('MapGraph', () => {
 
   // Test adding edges to the graph
   it('should add edges to the graph', () => {
-    const locationA = new MapVertex('A', 10, 20, 'Location A');
-    const locationB = new MapVertex('B', 30, 40, 'Location B');
+    const locationA = new MapVertex('A', 'Location A', 10, 20);
+    const locationB = new MapVertex('B', 'Location B', 30, 40);
     const edgeAB = new MapEdge('A', 'B', 50, 'Edge from A to B');
 
     mapGraph.addVertex(locationA);
@@ -79,12 +79,12 @@ describe('MapGraph', () => {
 
   // Test getting neighbors of a vertex
   it('should return the neighbors of a vertex', () => {
-    const locationA = new MapVertex('A', 10, 20, 'Location A');
+    const locationA = new MapVertex('A', 'Location A', 10, 20);
     locationA.lat = locationA.lat;
     locationA.long = locationA.long;
-    const locationB = mapGraph.createVertex('B', 30, 40, 'Location B');
+    const locationB = mapGraph.createVertex('B', 'Location B', 30, 40);
 
-    const locationC = new MapVertex('C', 50, 60, 'Location C');
+    const locationC = new MapVertex('C', 'Location C', 50, 60);
     const edgeAB = new MapEdge('A', 'B', 50, 'Edge from A to B');
     const edgeBC = new MapEdge('B', 'C', 60, 'Edge from B to C');
 
@@ -106,9 +106,9 @@ describe('MapGraph', () => {
 
   // Test finding the shortest path between locations
   it('should find the shortest path between two locations', () => {
-    const locationA = new MapVertex('A', 10, 20, 'Location A');
-    const locationB = new MapVertex('B', 30, 40, 'Location B');
-    const locationC = new MapVertex('C', 50, 60, 'Location C');
+    const locationA = new MapVertex('A', 'Location A', 10, 20);
+    const locationB = new MapVertex('B', 'Location B', 30, 40);
+    const locationC = new MapVertex('C', 'Location C', 50, 60);
     const edgeAB = new MapEdge('A', 'B', 50, 'Edge from A to B');
     const edgeBC = new MapEdge('B', 'C', 60, 'Edge from B to C');
 

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

@@ -7,6 +7,14 @@ describe('UndirectedGraph Operation Test', () => {
     graph = new UndirectedGraph();
   });
 
+  it('should edge cases', () => {
+    expect(graph.deleteEdge(new UndirectedEdge('c', 'd'))).toBe(null);
+    expect(graph.deleteEdgeBetween('c', 'd')).toBe(null);
+    expect(graph.degreeOf('c')).toBe(0);
+    expect(graph.edgesOf('c').length).toBe(0);
+    expect(graph.getEndsOfEdge(new UndirectedEdge('c', 'd'))).toBe(null);
+  });
+
   it('should add vertices', () => {
     const vertex1 = new UndirectedVertex('A');
     const vertex2 = new UndirectedVertex('B');
@@ -59,11 +67,11 @@ describe('UndirectedGraph Operation Test', () => {
 });
 
 describe('UndirectedGraph', () => {
-  let undirectedGraph: UndirectedGraph<UndirectedVertex<string>, UndirectedEdge<string>>;
+  let undirectedGraph: UndirectedGraph<string, string>;
 
   beforeEach(() => {
     // Create a new UndirectedGraph instance before each test
-    undirectedGraph = new UndirectedGraph<UndirectedVertex<string>, UndirectedEdge<string>>();
+    undirectedGraph = new UndirectedGraph<string, string>();
   });
 
   // Test adding vertices to the graph

package/test/unit/data-structures/hash/hash-table.test.ts

@@ -7,7 +7,7 @@ describe('HashNode', () => {
     const hashNode = new HashTableNode(key, value);
 
     expect(hashNode.key).toBe(key);
-    expect(hashNode.val).toBe(value);
+    expect(hashNode.value).toBe(value);
     expect(hashNode.next).toBe(null);
   });
 });

package/test/unit/data-structures/linked-list/doubly-linked-list.test.ts

@@ -4,9 +4,9 @@ import {bigO, magnitude} from '../../../utils';
 describe('DoublyLinkedListNode', () => {
   it('should DoublyLinkedListNode', () => {
     const node1 = new DoublyLinkedListNode<number>(2);
-    expect(node1.val).toBe(2);
-    node1.val = 1;
-    expect(node1.val).toBe(1);
+    expect(node1.value).toBe(2);
+    node1.value = 1;
+    expect(node1.value).toBe(1);
   });
 });
 
@@ -33,13 +33,13 @@ describe('DoublyLinkedList Operation Test', () => {
 
   it('should delete tail', () => {
     expect(list.delete(list.tail)).toBe(true);
-    expect(list.tail?.val).toBe(4);
+    expect(list.tail?.value).toBe(4);
     expect(list.delete(6)).toBe(false);
-    expect(list.tail?.val).toBe(4);
+    expect(list.tail?.value).toBe(4);
   });
 
   it('should find null', () => {
-    expect(list.find(val => val === 6)).toBe(null);
+    expect(list.find(value => value === 6)).toBe(null);
   });
 
   it('should indexOf -1', () => {
@@ -47,7 +47,7 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should findBackward null', () => {
-    expect(list.findBackward(val => val === 0)).toBe(null);
+    expect(list.findBackward(value => value === 0)).toBe(null);
   });
 
   it('should insertAfter tail', () => {
@@ -80,8 +80,8 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
     expect(list.length).toBe(3);
-    expect(list.head!.val).toBe(1);
-    expect(list.tail!.val).toBe(3);
+    expect(list.head!.value).toBe(1);
+    expect(list.tail!.value).toBe(3);
   });
 
   it('should pop elements from the end of the list', () => {
@@ -90,8 +90,8 @@ describe('DoublyLinkedList Operation Test', () => {
     const poppedValue = list.pop();
     expect(poppedValue).toBe(2);
     expect(list.length).toBe(1);
-    expect(list.head!.val).toBe(1);
-    expect(list.tail!.val).toBe(1);
+    expect(list.head!.value).toBe(1);
+    expect(list.tail!.value).toBe(1);
   });
   it('should insert elements at specific positions', () => {
     list.push(1);
@@ -114,7 +114,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.insertAt(5, 4);
     expect(list.length).toBe(6);
     expect(list.getAt(5)).toBe(4);
-    expect(list.tail!.val).toBe(4);
+    expect(list.tail!.value).toBe(4);
   });
 
   it('should delete elements at specific positions', () => {
@@ -126,12 +126,12 @@ describe('DoublyLinkedList Operation Test', () => {
     const deletedValue = list.deleteAt(0);
     expect(deletedValue).toBe(1);
     expect(list.length).toBe(2);
-    expect(list.head!.val).toBe(2);
+    expect(list.head!.value).toBe(2);
 
     // Deleting from the middle
     list.deleteAt(0); // Deleting the second element
     expect(list.length).toBe(1);
-    expect(list.head!.val).toBe(3);
+    expect(list.head!.value).toBe(3);
 
     // Deleting from the end
     list.deleteAt(0);
@@ -147,12 +147,12 @@ describe('DoublyLinkedList Operation Test', () => {
 
     list.delete(2);
     expect(list.length).toBe(2);
-    expect(list.head!.val).toBe(1);
-    expect(list.tail!.val).toBe(3);
+    expect(list.head!.value).toBe(1);
+    expect(list.tail!.value).toBe(3);
 
     list.delete(1);
     expect(list.length).toBe(1);
-    expect(list.head!.val).toBe(3);
+    expect(list.head!.value).toBe(3);
 
     list.delete(3);
     expect(list.length).toBe(0);
@@ -176,7 +176,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const mappedList = list.map(val => val * 2);
+    const mappedList = list.map(value => value * 2);
 
     expect(mappedList.toArray()).toEqual([2, 4, 6]);
   });
@@ -187,7 +187,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
     list.push(4);
 
-    const filteredList = list.filter(val => val % 2 === 0);
+    const filteredList = list.filter(value => value % 2 === 0);
 
     expect(filteredList.toArray()).toEqual([2, 4]);
   });
@@ -198,7 +198,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
     list.push(4);
 
-    const sum = list.reduce((acc, val) => acc + val, 0);
+    const sum = list.reduce((acc, value) => acc + value, 0);
 
     expect(sum).toBe(10);
   });
@@ -227,7 +227,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const found = list.find(val => val % 2 === 0);
+    const found = list.find(value => value % 2 === 0);
 
     expect(found).toBe(2);
   });
@@ -248,7 +248,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
     list.push(4);
 
-    const lastEven = list.findBackward(val => val % 2 === 0);
+    const lastEven = list.findBackward(value => value % 2 === 0);
 
     expect(lastEven).toBe(4);
   });
@@ -283,8 +283,8 @@ describe('DoublyLinkedList Operation Test', () => {
     list.reverse();
 
     expect(list.toArray()).toEqual([3, 2, 1]);
-    expect(list.head?.val).toBe(3);
-    expect(list.tail?.val).toBe(1);
+    expect(list.head?.value).toBe(3);
+    expect(list.tail?.value).toBe(1);
   });
 
   it('should iterate over each element and apply a callback', () => {
@@ -293,8 +293,8 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
 
     const result: number[] = [];
-    list.forEach(val => {
-      result.push(val * 2);
+    list.forEach(value => {
+      result.push(value * 2);
     });
 
     expect(result).toEqual([2, 4, 6]);
@@ -305,7 +305,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const mappedList = list.map(val => val * 2);
+    const mappedList = list.map(value => value * 2);
 
     expect(mappedList.toArray()).toEqual([2, 4, 6]);
   });
@@ -316,7 +316,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
     list.push(4);
 
-    const filteredList = list.filter(val => val % 2 === 0);
+    const filteredList = list.filter(value => value % 2 === 0);
 
     expect(filteredList.toArray()).toEqual([2, 4]);
   });
@@ -326,7 +326,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const sum = list.reduce((acc, val) => acc + val, 0);
+    const sum = list.reduce((acc, value) => acc + value, 0);
 
     expect(sum).toBe(6);
   });
@@ -387,7 +387,7 @@ describe('DoublyLinkedList Operation Test', () => {
     expect(insertSuccess).toBe(true);
 
     const getNode = objectList.getNode(newObj); // Use newObj instead of obj2
-    expect(getNode?.val).toEqual(newObj);
+    expect(getNode?.value).toEqual(newObj);
 
     const deleted = objectList.delete(newObj); // Use newObj instead of obj2
     expect(deleted).toBe(true);

package/test/unit/data-structures/linked-list/linked-list.test.ts

@@ -26,7 +26,7 @@ describe('LinkedList Performance Test', () => {
       if (i === midIndex) {
         midSinglyNode = singlyList.getNode(i);
       } else if (i > midIndex && midSinglyNode) {
-        singlyList.insertBefore(midSinglyNode.val, i);
+        singlyList.insertBefore(midSinglyNode.value, i);
       }
     }
 

package/test/unit/data-structures/linked-list/singly-linked-list.test.ts

@@ -4,9 +4,9 @@ import {bigO, magnitude} from '../../../utils';
 describe('SinglyLinkedListNode', () => {
   it('should SinglyLinkedList', () => {
     const node1 = new SinglyLinkedListNode<number>(2);
-    expect(node1.val).toBe(2);
-    node1.val = 1;
-    expect(node1.val).toBe(1);
+    expect(node1.value).toBe(2);
+    node1.value = 1;
+    expect(node1.value).toBe(1);
   });
 });
 
@@ -75,7 +75,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(3);
       const element = list.getAt(1);
       expect(element).toBe(2);
-      expect(list.getNodeAt(2)?.val).toBe(3);
+      expect(list.getNodeAt(2)?.value).toBe(3);
     });
 
     it('should return undefined for an out-of-bounds index', () => {
@@ -382,7 +382,7 @@ describe('SinglyLinkedList Operation Test', () => {
     expect(insertSuccess).toBe(true);
 
     const getNode = objectList.getNode(newObj); // Use newObj instead of obj2
-    expect(getNode?.val).toEqual(newObj);
+    expect(getNode?.value).toEqual(newObj);
 
     const deleted = objectList.delete(newObj); // Use newObj instead of obj2
     expect(deleted).toBe(true);
@@ -431,8 +431,8 @@ describe('SinglyLinkedList', () => {
   it('should push elements to the end of the list', () => {
     list.push(1);
     list.push(2);
-    expect(list.head!.val).toBe(1);
-    expect(list.tail!.val).toBe(2);
+    expect(list.head!.value).toBe(1);
+    expect(list.tail!.value).toBe(2);
     expect(list.length).toBe(2);
   });
 
@@ -441,8 +441,8 @@ describe('SinglyLinkedList', () => {
     list.push(2);
     const popped = list.pop();
     expect(popped).toBe(2);
-    expect(list.head!.val).toBe(1);
-    expect(list.tail!.val).toBe(1);
+    expect(list.head!.value).toBe(1);
+    expect(list.tail!.value).toBe(1);
     expect(list.length).toBe(1);
   });
 
@@ -451,8 +451,8 @@ describe('SinglyLinkedList', () => {
     list.push(2);
     list.push(3);
     list.reverse();
-    expect(list.head!.val).toBe(3);
-    expect(list.tail!.val).toBe(1);
+    expect(list.head!.value).toBe(3);
+    expect(list.tail!.value).toBe(1);
     // Add more assertions for reversed order.
   });
 
@@ -470,14 +470,14 @@ describe('SinglyLinkedList', () => {
     list.push(1);
     list.push(2);
     list.push(3);
-    expect(list.filter(val => val !== 2).toArray()).toEqual([1, 3]);
+    expect(list.filter(value => value !== 2).toArray()).toEqual([1, 3]);
   });
 
   it('should forEach the list', () => {
     list.push(1);
     list.push(2);
     list.push(3);
-    list.forEach(val => val++);
+    list.forEach(value => value++);
     expect(list.toArray()).toEqual([1, 2, 3]);
   });
 
@@ -485,11 +485,11 @@ describe('SinglyLinkedList', () => {
     list.addLast(1);
     list.push(2);
     list.push(3);
-    expect(list.map(val => val * 2).toArray()).toEqual([2, 4, 6]);
+    expect(list.map(value => value * 2).toArray()).toEqual([2, 4, 6]);
   });
 
   it('should reduce the list', () => {
     const list1 = SinglyLinkedList.fromArray([1, 2, 3]);
-    expect(list1.reduce((acc, val) => acc + val, 0)).toEqual(6);
+    expect(list1.reduce((acc, value) => acc + value, 0)).toEqual(6);
   });
 });

package/test/unit/data-structures/queue/queue.test.ts

@@ -1,4 +1,4 @@
-import {LinkedListQueue, Queue} from '../../../../src';
+import {SkipQueue, Queue} from '../../../../src';
 import {bigO, magnitude} from '../../../utils';
 import {isDebugTest} from '../../../config';
 
@@ -168,11 +168,11 @@ describe('Queue', () => {
     expect(values).toEqual([1, 2, 3]);
   });
 });
-describe('LinkedListQueue', () => {
-  let queue: LinkedListQueue<string>;
+describe('SkipQueue', () => {
+  let queue: SkipQueue<string>;
 
   beforeEach(() => {
-    queue = new LinkedListQueue<string>();
+    queue = new SkipQueue<string>();
   });
 
   it('should enqueue elements to the end of the queue', () => {
@@ -197,7 +197,7 @@ describe('LinkedListQueue', () => {
     expect(queue.peek()).toBe('A');
   });
 
-  // Add more test cases for other methods of LinkedListQueue.
+  // Add more test cases for other methods of SkipQueue.
 });
 
 describe('Queue Performance Test', () => {
@@ -228,16 +228,16 @@ describe('Queue Performance Test', () => {
     expect(performance.now() - startTime2).toBeLessThan(bigO.CUBED * 100);
   });
 
-  it('should numeric LinkedListQueue be efficient', function () {
+  it('should numeric SkipQueue be efficient', function () {
     const startTime = performance.now();
-    const queue = new LinkedListQueue<number>();
+    const queue = new SkipQueue<number>();
     for (let i = 0; i < dataSize; i++) {
       queue.enqueue(i);
     }
     for (let i = 0; i < dataSize; i++) {
       queue.dequeue();
     }
-    console.log(`LinkedListQueue Performance Test: ${performance.now() - startTime} ms`);
+    console.log(`SkipQueue Performance Test: ${performance.now() - startTime} ms`);
     expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
   });
 });

package/test/utils/big-o.ts

@@ -59,19 +59,19 @@ function findPotentialN(input: any): number {
 function linearRegression(x: number[], y: number[]) {
   const n = x.length;
 
-  const sumX = x.reduce((acc, val) => acc + val, 0);
-  const sumY = y.reduce((acc, val) => acc + val, 0);
+  const sumX = x.reduce((acc, value) => acc + value, 0);
+  const sumY = y.reduce((acc, value) => acc + value, 0);
 
-  const sumXSquared = x.reduce((acc, val) => acc + val ** 2, 0);
-  const sumXY = x.reduce((acc, val, i) => acc + val * y[i], 0);
+  const sumXSquared = x.reduce((acc, value) => acc + value ** 2, 0);
+  const sumXY = x.reduce((acc, value, i) => acc + value * y[i], 0);
 
   const slope = (n * sumXY - sumX * sumY) / (n * sumXSquared - sumX ** 2);
   const intercept = (sumY - slope * sumX) / n;
 
-  const yHat = x.map(val => slope * val + intercept);
+  const yHat = x.map(value => slope * value + intercept);
 
-  const totalVariation = y.map((val, i) => (val - yHat[i]) ** 2).reduce((acc, val) => acc + val, 0);
-  const explainedVariation = y.map(val => (val - sumY / n) ** 2).reduce((acc, val) => acc + val, 0);
+  const totalVariation = y.map((value, i) => (value - yHat[i]) ** 2).reduce((acc, value) => acc + value, 0);
+  const explainedVariation = y.map(value => (value - sumY / n) ** 2).reduce((acc, value) => acc + value, 0);
 
   const rSquared = 1 - totalVariation / explainedVariation;