data-structure-typed 1.52.4 → 1.52.6

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

@@ -9,6 +9,16 @@ describe('SinglyLinkedListNode', () => {
   });
 });
 
+describe('SinglyLinkedList Initiate Test', () => {
+  it('should initiate with toElementFn', () => {
+    const sl = new SinglyLinkedList([{ key: 1 }, { key: 2 }, { key: 3 }, { key: 4 }, { key: 5 }], {
+      toElementFn: ({ key }) => key
+    });
+
+    expect([...sl]).toEqual([1, 2, 3, 4, 5]);
+  });
+});
+
 describe('SinglyLinkedList Operation Test', () => {
   let list: SinglyLinkedList<number>;
   let objectList: SinglyLinkedList<{
@@ -95,6 +105,10 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(3);
       list.addAfter(2, 4);
       expect(list.toArray()).toEqual([1, 2, 4, 3]);
+      list.addAfter(list.getNode(2)!, 4);
+      expect(list.toArray()).toEqual([1, 2, 4, 4, 3]);
+      list.addAfter(list.getNode(3)!, 4);
+      expect(list.toArray()).toEqual([1, 2, 4, 4, 3, 4]);
     });
 
     it('should return false if the existing value is not found', () => {
@@ -132,12 +146,17 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(3);
       list.push(4);
       list.push(5);
+      expect(list.delete(undefined)).toBe(false);
       expect(list.delete(2)).toBe(true);
       expect(list.toArray()).toEqual([1, 3, 4, 5]);
       expect(list.delete(1)).toBe(true);
       expect(list.toArray()).toEqual([3, 4, 5]);
       expect(list.delete(5)).toBe(true);
       expect(list.toArray()).toEqual([3, 4]);
+      expect(list.delete(4)).toBe(true);
+      expect(list.toArray()).toEqual([3]);
+      expect(list.delete(3)).toBe(true);
+      expect(list.toArray()).toEqual([]);
     });
 
     it('should return false if the value is not found', () => {
@@ -229,11 +248,14 @@ describe('SinglyLinkedList Operation Test', () => {
 
   describe('addBefore', () => {
     it('should insert an element before an existing value', () => {
+      expect(list.addBefore(2, 4)).toBe(false);
       list.push(1);
       list.push(2);
       list.push(3);
       list.addBefore(2, 4);
       expect(list.toArray()).toEqual([1, 4, 2, 3]);
+      expect(list.addBefore(list.getNode(2)!, 4)).toBe(true);
+      expect([...list]).toEqual([1, 4, 4, 2, 3]);
     });
 
     it('should insert an element at the beginning', () => {
@@ -281,7 +303,11 @@ describe('SinglyLinkedList Operation Test', () => {
     it('should delete and return the first element', () => {
       list.push(1);
       list.push(2);
+      expect(list.first).toBe(1);
+      expect(list.last).toBe(2);
       const removed = list.deleteAt(0);
+      expect(list.first).toBe(2);
+      expect(list.last).toBe(2);
       expect(removed).toBe(true);
       expect(list.toArray()).toEqual([2]);
     });
@@ -321,6 +347,9 @@ describe('SinglyLinkedList Operation Test', () => {
       list.addAt(1, 3);
       list.addAt(1, 2);
       expect(list.toArray()).toEqual([1, 2, 3]);
+      expect(list.addAt(5, 5)).toBe(false);
+      expect(list.addAt(-1, -1)).toBe(false);
+      expect(list.toArray()).toEqual([1, 2, 3]);
     });
   });
 
@@ -354,6 +383,7 @@ describe('SinglyLinkedList Operation Test', () => {
 
   it('should clone', function () {
     const sList = new SinglyLinkedList<string>();
+    sList.delete('1');
     sList.push('1');
     sList.push('6');
     sList.push('2');
@@ -367,6 +397,8 @@ describe('SinglyLinkedList Operation Test', () => {
     sList.delete('5');
     expect([...sList]).toEqual(['1', '6', '0', '9']);
     expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
+    sList.delete(sList.getNode('0'));
+    expect([...sList]).toEqual(['1', '6', '9']);
   });
 
   describe('countOccurrences', () => {

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

@@ -22,6 +22,14 @@ describe('Matrix', () => {
     ]);
   });
 
+  it('should initiate with empty', () => {
+    matrix = new Matrix([], { rows: 2, cols: 2 });
+    expect(matrix.data).toEqual([
+      [0, 0],
+      [0, 0]
+    ]);
+  });
+
   it('should get a value at a specific position', () => {
     expect(matrix.get(1, 1)).toBe(0);
     expect(matrix.get(2, 2)).toBe(0);
@@ -213,7 +221,7 @@ describe('Matrix', () => {
   });
 
   describe('transpose', () => {
-    test('should transpose a matrix with numeric values correctly', () => {
+    it('should transpose a matrix with numeric values correctly', () => {
       const originalMatrix = new Matrix([
         [1, 2, 3],
         [4, 5, 6],
@@ -231,7 +239,7 @@ describe('Matrix', () => {
       ]);
     });
 
-    test('should transpose an empty matrix correctly', () => {
+    it('should transpose an empty matrix correctly', () => {
       const originalMatrix = new Matrix([]);
 
       const transposedMatrix = originalMatrix.transpose();
@@ -241,7 +249,7 @@ describe('Matrix', () => {
       expect(transposedMatrix.data).toEqual([]);
     });
 
-    test('should throw an error when transposing a non-rectangular matrix', () => {
+    it('should throw an error when transposing a non-rectangular matrix', () => {
       const originalMatrix = new Matrix([
         [1, 2, 3],
         [4, 5]
@@ -292,10 +300,32 @@ describe('Matrix', () => {
         [-0.046511627906976744, -0.023255813953488372, 0.23255813953488372]
       ]);
     });
+
+    it('should throw error when cols does not equal to rows', () => {
+      const data: number[][] = [
+        [4, 7, 2],
+        [2, 6, 3]
+      ];
+
+      const matrix = new Matrix(data);
+      expect(() => matrix.inverse()).toThrow('Matrix must be square for inversion.');
+    });
+
+    it('should clone', () => {
+      const data: number[][] = [
+        [4, 7, 2],
+        [2, 6, 3]
+      ];
+
+      const matrix = new Matrix(data);
+      const cloned = matrix.clone();
+      expect(cloned instanceof Matrix).toBe(true);
+      expect(cloned.data).toEqual(data);
+    });
   });
 
   describe('dot', () => {
-    test('should calculate the dot product of two matrices', () => {
+    it('should calculate the dot product of two matrices', () => {
       const matrix1 = new Matrix([
         [1, 2],
         [3, 4]
@@ -313,7 +343,7 @@ describe('Matrix', () => {
       ]);
     });
 
-    test('should throw an error for incompatible matrices', () => {
+    it('should throw an error for incompatible matrices', () => {
       const matrix1 = new Matrix([
         [1, 2],
         [3, 4]

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

@@ -129,4 +129,35 @@ describe('MaxPriorityQueue Operation Test', () => {
 
     expect([...maxPQ.sort()]).toEqual([8, 7, 6, 5, 4, 3, 1]);
   });
+
+  it('should MaxPriorityQueue filter, map work well', function () {
+    const minPQ2 = new MaxPriorityQueue<number>([]);
+    minPQ2.refill([2, 5, 8, 1, 6, 7, 4]);
+
+    const cloned = minPQ2.clone();
+    const filtered = cloned.filter(item => item % 2 === 1);
+    expect(filtered instanceof MaxPriorityQueue).toBe(true);
+    expect([...filtered]).toEqual([7, 1, 5]);
+
+    const mapped = filtered.map(
+      item => ({ key: item }),
+      (a, b) => b.key - a.key
+    );
+    expect(mapped instanceof MaxPriorityQueue).toBe(true);
+    expect([...mapped]).toEqual([{ key: 7 }, { key: 1 }, { key: 5 }]);
+  });
+
+  it('should MaxPriorityQueue throw an error while initialed with object data', function () {
+    expect(() => {
+      new MaxPriorityQueue<{ key: number }>([{ key: 7 }, { key: 1 }, { key: 7 }]);
+    }).toThrow(
+      "When comparing object types, a custom comparator must be defined in the constructor's options parameter."
+    );
+  });
+
+  it('should MaxPriorityQueue comparator return 0 when equal values are added', function () {
+    const duplicated = new MaxPriorityQueue<number>([7, 1, 7, 7]);
+    expect(duplicated.size).toBe(4);
+    expect([...duplicated]).toEqual([7, 7, 7, 1]);
+  });
 });

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

@@ -60,4 +60,22 @@ describe('MinPriorityQueue Operation Test', () => {
     const sortedArray = priorityQueue.sort();
     expect(sortedArray).toEqual([1, 3, 5, 7]);
   });
+
+  it('should MinPriorityQueue filter, map work well', function () {
+    const minPQ2 = new MinPriorityQueue<number>([]);
+    minPQ2.refill([2, 5, 8, 1, 6, 7, 4]);
+
+    const cloned = minPQ2.clone();
+    const filtered = cloned.filter(item => item % 2 === 1);
+    expect(filtered instanceof MinPriorityQueue).toBe(true);
+    expect([...filtered]).toEqual([1, 5, 7]);
+
+    const mapped = filtered.map(
+      item => ({ key: item }),
+      (a, b) => a.key - b.key
+    );
+    expect(mapped instanceof MinPriorityQueue).toBe(true);
+    expect([...mapped]).toEqual([{ key: 1 }, { key: 5 }, { key: 7 }]);
+    expect(mapped.print()).toEqual([{ key: 1 }, { key: 5 }, { key: 7 }]);
+  });
 });

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

@@ -52,6 +52,23 @@ describe('PriorityQueue Operation Test', () => {
     expect(minPQ1.dfs('POST')).toEqual([4, 3, 5, 2, 8, 7, 6, 1]);
     expect(minPQ1.dfs('PRE')).toEqual([1, 2, 3, 4, 5, 6, 8, 7]);
   });
+
+  it('should PriorityQueue filter, map work well', function () {
+    const minPQ2 = new PriorityQueue<number>([], {
+      comparator: (a, b) => a - b
+    });
+    minPQ2.refill([2, 5, 8, 3, 1, 6, 7, 4]);
+    const filtered = minPQ2.filter(item => item % 2 === 1);
+    expect(filtered instanceof PriorityQueue).toBe(true);
+    expect([...filtered]).toEqual([1, 3, 5, 7]);
+
+    const mapped = filtered.map(
+      item => ({ key: item }),
+      (a, b) => a.key - b.key
+    );
+    expect(mapped instanceof PriorityQueue).toBe(true);
+    expect([...mapped]).toEqual([{ key: 1 }, { key: 3 }, { key: 5 }, { key: 7 }]);
+  });
 });
 
 describe('Priority Queue Performance Test', () => {