data-structure-typed 1.40.0-rc → 1.41.0

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

@@ -2,54 +2,37 @@ import {PriorityQueue} from '../../../../src';
 import {getRandomInt} from '../../../utils';
 
 describe('PriorityQueue Operation Test', () => {
-  it('should validate a priority queue', () => {
-    const minPQ = new PriorityQueue<number>({nodes: [1, 5, 7, 9, 3, 6, 2], comparator: (a, b) => a - b});
-
-    expect(minPQ.isValid()).toBe(true);
-    expect(PriorityQueue.isPriorityQueueified({nodes: minPQ.nodes, comparator: (a, b) => a - b})).toBe(true);
-    expect(PriorityQueue.isPriorityQueueified({nodes: minPQ.nodes, comparator: (a, b) => b - a})).toBe(false);
-    expect(
-      PriorityQueue.isPriorityQueueified({
-        nodes: [1, 5, 7, 9, 3, 6, 2],
-        comparator: (a, b) => b - a
-      })
-    ).toBe(false);
-  });
-
   it('should PriorityQueue poll, pee, heapify, toArray work well', function () {
-    const minPQ = new PriorityQueue<number>({nodes: [5, 2, 3, 4, 6, 1], comparator: (a, b) => a - b});
+    const minPQ = new PriorityQueue<number>({comparator: (a, b) => a - b});
+    minPQ.refill([5, 2, 3, 4, 6, 1]);
     expect(minPQ.toArray()).toEqual([1, 2, 3, 4, 6, 5]);
     minPQ.poll();
     minPQ.poll();
     minPQ.poll();
     expect(minPQ.toArray()).toEqual([4, 5, 6]);
     expect(minPQ.peek()).toBe(4);
-    expect(
-      PriorityQueue.heapify({
-        nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10],
-        comparator: (a, b) => a - b
-      }).toArray()
-    ).toEqual([1, 2, 3, 5, 6, 7, 8, 9, 10]);
+    expect(PriorityQueue.heapify({nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10], comparator: (a, b) => a - b}).toArray()).toEqual(
+      [1, 2, 3, 5, 6, 7, 8, 9, 10]
+    );
   });
 
   it('should Max PriorityQueue poll, peek, heapify, toArray work well', function () {
-    const maxPriorityQueue = new PriorityQueue<number>({nodes: [5, 2, 3, 4, 6, 1], comparator: (a, b) => b - a});
+    const maxPriorityQueue = new PriorityQueue<number>({comparator: (a, b) => b - a});
+    maxPriorityQueue.refill([5, 2, 3, 4, 6, 1]);
     expect(maxPriorityQueue.toArray()).toEqual([6, 5, 3, 4, 2, 1]);
     maxPriorityQueue.poll();
     maxPriorityQueue.poll();
     maxPriorityQueue.poll();
     expect(maxPriorityQueue.toArray()).toEqual([3, 2, 1]);
     expect(maxPriorityQueue.peek()).toBe(3);
-    expect(
-      PriorityQueue.heapify({
-        nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10],
-        comparator: (a, b) => a - b
-      }).toArray()
-    ).toEqual([1, 2, 3, 5, 6, 7, 8, 9, 10]);
+    expect(PriorityQueue.heapify({nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10], comparator: (a, b) => a - b}).toArray()).toEqual(
+      [1, 2, 3, 5, 6, 7, 8, 9, 10]
+    );
   });
 
   it('should PriorityQueue clone, sort, getNodes, dfs work well', function () {
-    const minPQ1 = new PriorityQueue<number>({nodes: [2, 5, 8, 3, 1, 6, 7, 4], comparator: (a, b) => a - b});
+    const minPQ1 = new PriorityQueue<number>({comparator: (a, b) => a - b});
+    minPQ1.refill([2, 5, 8, 3, 1, 6, 7, 4]);
     const clonedPriorityQueue = minPQ1.clone();
     expect(clonedPriorityQueue.getNodes()).toEqual(minPQ1.getNodes());
     expect(clonedPriorityQueue.sort()).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
@@ -62,7 +45,8 @@ describe('PriorityQueue Operation Test', () => {
 describe('Priority Queue Performance Test', () => {
   it('should numeric heap work well', function () {
     const values = Array.from(new Array(10000), () => getRandomInt(1, 10000000));
-    const minPriorityQueue = new PriorityQueue<number>({nodes: values, comparator: (a, b) => a - b});
+    const minPriorityQueue = new PriorityQueue<number>({comparator: (a, b) => a - b});
+    minPriorityQueue.refill(values);
     const sorted = minPriorityQueue.sort();
     expect(sorted).toEqual(values.sort((a, b) => a - b));
   });

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

@@ -1,5 +1,8 @@
-import {Deque, ArrayDeque, ObjectDeque} from '../../../../src';
+import {ArrayDeque, Deque, ObjectDeque} from '../../../../src';
+import {bigO} from '../../../utils';
+import {isDebugTest} from '../../../config';
 
+const isDebug = isDebugTest;
 describe('Deque Tests', () => {
   // Test cases for the Deque class (DoublyLinkedList-based)
   describe('Deque (DoublyLinkedList-based)', () => {
@@ -12,20 +15,20 @@ describe('Deque Tests', () => {
     it('should add elements at the beginning and end', () => {
       deque.addFirst(1);
       deque.addLast(2);
-      expect(deque.peekFirst()).toBe(1);
-      expect(deque.peekLast()).toBe(2);
+      expect(deque.getFirst()).toBe(1);
+      expect(deque.getLast()).toBe(2);
     });
 
-    it('should remove elements from the beginning and end', () => {
+    it('should delete elements from the beginning and end', () => {
       deque.addFirst(1);
       deque.addLast(2);
-      deque.pollFirst();
-      deque.pollLast();
+      deque.popFirst();
+      deque.popLast();
       expect(deque.isEmpty()).toBe(true);
     });
 
     it('should handle edge case when removing from an empty deque', () => {
-      const result = deque.pollFirst();
+      const result = deque.popFirst();
       expect(result).toBeUndefined();
     });
 
@@ -37,18 +40,18 @@ describe('Deque Tests', () => {
 
     it('should handle adding and removing elements alternately', () => {
       deque.addFirst(1);
-      expect(deque.pollFirst()).toBe(1);
+      expect(deque.popFirst()).toBe(1);
       deque.addLast(2);
-      expect(deque.pollLast()).toBe(2);
+      expect(deque.popLast()).toBe(2);
       expect(deque.isEmpty()).toBe(true);
     });
 
     it('should handle adding and removing elements in a cyclic manner', () => {
       deque.addFirst(1);
       deque.addLast(2);
-      expect(deque.pollFirst()).toBe(1);
+      expect(deque.popFirst()).toBe(1);
       deque.addFirst(3);
-      expect(deque.pollLast()).toBe(2);
+      expect(deque.popLast()).toBe(2);
       expect(deque.size).toBe(1);
     });
     // Add more test cases as needed
@@ -65,20 +68,20 @@ describe('Deque Tests', () => {
     it('should add elements at the beginning and end', () => {
       objectDeque.addFirst('one');
       objectDeque.addLast('two');
-      expect(objectDeque.peekFirst()).toBe('one');
-      expect(objectDeque.peekLast()).toBe('two');
+      expect(objectDeque.getFirst()).toBe('one');
+      expect(objectDeque.getLast()).toBe('two');
     });
 
-    it('should remove elements from the beginning and end', () => {
+    it('should delete elements from the beginning and end', () => {
       objectDeque.addFirst('one');
       objectDeque.addLast('two');
-      objectDeque.pollFirst();
-      objectDeque.pollLast();
+      objectDeque.popFirst();
+      objectDeque.popLast();
       expect(objectDeque.isEmpty()).toBe(true);
     });
 
     it('should handle edge case when removing from an empty deque', () => {
-      const result = objectDeque.pollFirst();
+      const result = objectDeque.popFirst();
       expect(result).toBeUndefined();
     });
 
@@ -102,20 +105,20 @@ describe('Deque Tests', () => {
     it('should add elements at the beginning and end', () => {
       arrayDeque.addFirst(1);
       arrayDeque.addLast(2);
-      expect(arrayDeque.peekFirst()).toBe(1);
-      expect(arrayDeque.peekLast()).toBe(2);
+      expect(arrayDeque.getFirst()).toBe(1);
+      expect(arrayDeque.getLast()).toBe(2);
     });
 
-    it('should remove elements from the beginning and end', () => {
+    it('should delete elements from the beginning and end', () => {
       arrayDeque.addFirst(1);
       arrayDeque.addLast(2);
-      arrayDeque.pollFirst();
-      arrayDeque.pollLast();
+      arrayDeque.popFirst();
+      arrayDeque.popLast();
       expect(arrayDeque.isEmpty()).toBe(true);
     });
 
     it('should handle edge case when removing from an empty deque', () => {
-      const result = arrayDeque.pollFirst();
+      const result = arrayDeque.popFirst();
       expect(result).toBeNull();
     });
 
@@ -128,3 +131,280 @@ describe('Deque Tests', () => {
     // Add more test cases as needed
   });
 });
+
+describe('Deque Performance Test', () => {
+  const dataSize = 10000;
+  it('should numeric queue be efficient', function () {
+    const startTime = performance.now();
+    const queue = new Deque<number>();
+    for (let i = 0; i < dataSize; i++) {
+      queue.unshift(i);
+    }
+    for (let i = 0; i < dataSize; i++) {
+      queue.pop();
+    }
+    isDebug && console.log(`Queue Deque Test: ${performance.now() - startTime} ms`);
+    expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
+  });
+});
+
+describe('Deque', () => {
+  let deque: Deque<number>;
+
+  beforeEach(() => {
+    deque = new Deque<number>();
+  });
+
+  test('should initialize an empty deque', () => {
+    expect(deque.size).toBe(0);
+    expect(deque.isEmpty()).toBe(true);
+  });
+
+  test('should add elements to the front and back', () => {
+    deque.addFirst(1);
+    deque.addLast(2);
+
+    expect(deque.size).toBe(2);
+    expect(deque.getFirst()).toBe(1);
+    expect(deque.getLast()).toBe(2);
+  });
+
+  test('should remove elements from the front and back', () => {
+    deque.addFirst(1);
+    deque.addLast(2);
+
+    const firstElement = deque.popFirst();
+    const lastElement = deque.popLast();
+
+    expect(deque.size).toBe(0);
+    expect(firstElement).toBe(1);
+    expect(lastElement).toBe(2);
+  });
+
+  test('should get elements by index', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+    deque.addLast(3);
+
+    expect(deque.getAt(0)).toBe(1);
+    expect(deque.getAt(1)).toBe(2);
+    expect(deque.getAt(2)).toBe(3);
+  });
+
+  test('should return null for out-of-bounds index', () => {
+    expect(deque.getAt(0)).toBe(undefined);
+    expect(deque.getAt(1)).toBe(undefined);
+    expect(deque.getAt(-1)).toBe(undefined);
+  });
+
+  test('should check if the deque is empty', () => {
+    expect(deque.isEmpty()).toBe(true);
+
+    deque.addLast(1);
+    expect(deque.isEmpty()).toBe(false);
+
+    deque.popFirst();
+    expect(deque.isEmpty()).toBe(true);
+  });
+});
+
+describe('ArrayDeque', () => {
+  let deque: ArrayDeque<number>;
+
+  beforeEach(() => {
+    deque = new ArrayDeque<number>();
+  });
+
+  test('should initialize an empty deque', () => {
+    expect(deque.size).toBe(0);
+    expect(deque.isEmpty()).toBe(true);
+  });
+
+  test('should add elements to the front and back', () => {
+    deque.addFirst(1);
+    deque.addLast(2);
+
+    expect(deque.size).toBe(2);
+    expect(deque.getFirst()).toBe(1);
+    expect(deque.getLast()).toBe(2);
+  });
+
+  test('should remove elements from the front and back', () => {
+    deque.addFirst(1);
+    deque.addLast(2);
+
+    const firstElement = deque.popFirst();
+    const lastElement = deque.popLast();
+
+    expect(deque.size).toBe(0);
+    expect(firstElement).toBe(1);
+    expect(lastElement).toBe(2);
+  });
+
+  test('should get elements by index', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+    deque.addLast(3);
+
+    expect(deque.get(0)).toBe(1);
+    expect(deque.get(1)).toBe(2);
+    expect(deque.get(2)).toBe(3);
+  });
+
+  test('should return null for out-of-bounds index', () => {
+    expect(deque.get(0)).toBe(null);
+    expect(deque.get(1)).toBe(null);
+    expect(deque.get(-1)).toBe(null);
+  });
+
+  test('should check if the deque is empty', () => {
+    expect(deque.isEmpty()).toBe(true);
+
+    deque.addLast(1);
+    expect(deque.isEmpty()).toBe(false);
+
+    deque.popFirst();
+    expect(deque.isEmpty()).toBe(true);
+  });
+
+  test('should set elements at a specific index', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+    deque.addLast(3);
+
+    deque.set(1, 4);
+
+    expect(deque.get(0)).toBe(1);
+    expect(deque.get(1)).toBe(4);
+    expect(deque.get(2)).toBe(3);
+  });
+
+  test('should insert elements at a specific index', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+    deque.addLast(3);
+
+    deque.insert(1, 4);
+
+    expect(deque.size).toBe(4);
+    expect(deque.get(0)).toBe(1);
+    expect(deque.get(1)).toBe(4);
+    expect(deque.get(2)).toBe(2);
+    expect(deque.get(3)).toBe(3);
+  });
+
+  test('should delete elements at a specific index', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+    deque.addLast(3);
+
+    const deletedElement = deque.delete(1);
+
+    expect(deque.size).toBe(2);
+    expect(deletedElement[0]).toBe(2);
+    expect(deque.get(0)).toBe(1);
+    expect(deque.get(1)).toBe(3);
+  });
+});
+
+describe('ObjectDeque', () => {
+  let deque: ObjectDeque<number>;
+
+  beforeEach(() => {
+    deque = new ObjectDeque<number>();
+  });
+
+  test('should add elements to the front of the deque', () => {
+    deque.addFirst(1);
+    deque.addFirst(2);
+
+    expect(deque.size).toBe(2);
+    expect(deque.getFirst()).toBe(2);
+    expect(deque.getLast()).toBe(1);
+  });
+
+  test('should add elements to the end of the deque', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+
+    expect(deque.size).toBe(2);
+    expect(deque.getFirst()).toBe(1);
+    expect(deque.getLast()).toBe(2);
+  });
+
+  test('should remove elements from the front of the deque', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+
+    const removedElement = deque.popFirst();
+
+    expect(deque.size).toBe(1);
+    expect(removedElement).toBe(1);
+    expect(deque.getFirst()).toBe(2);
+  });
+
+  test('should remove elements from the end of the deque', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+
+    const removedElement = deque.popFirst();
+
+    expect(deque.size).toBe(1);
+    expect(removedElement).toBe(1);
+    expect(deque.getLast()).toBe(2);
+  });
+
+  test('should return the element at the front of the deque without removing it', () => {
+    deque.addFirst(1);
+    deque.addFirst(2);
+
+    expect(deque.getFirst()).toBe(2);
+    expect(deque.size).toBe(2);
+  });
+
+  test('should return the element at the end of the deque without removing it', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+
+    expect(deque.getLast()).toBe(2);
+    expect(deque.size).toBe(2);
+  });
+
+  test('should return the correct size of the deque', () => {
+    deque.addFirst(1);
+    deque.addLast(2);
+    deque.addLast(3);
+
+    expect(deque.size).toBe(3);
+  });
+
+  test('should check if the deque is empty', () => {
+    expect(deque.isEmpty()).toBe(true);
+
+    deque.addFirst(1);
+
+    expect(deque.isEmpty()).toBe(false);
+  });
+
+  test('should set elements at a specific index', () => {
+    deque.addFirst(1);
+    deque.addLast(2);
+    deque.addLast(3);
+
+    expect(deque.getFirst()).toBe(1);
+    expect(deque.get(1)).toBe(2);
+    expect(deque.getLast()).toBe(3);
+  });
+
+  test('should insert elements at a specific index', () => {
+    deque.addFirst(1);
+    deque.addLast(2);
+    deque.addLast(3);
+
+    expect(deque.size).toBe(3);
+    expect(deque.getFirst()).toBe(1);
+    expect(deque.get(1)).toBe(2);
+    expect(deque.get(2)).toBe(3);
+    expect(deque.getLast()).toBe(3);
+  });
+});

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

@@ -1,6 +1,8 @@
-import {Queue, LinkedListQueue} from '../../../../src';
+import {LinkedListQueue, Queue} from '../../../../src';
 import {bigO, magnitude} from '../../../utils';
+import {isDebugTest} from '../../../config';
 
+const isDebug = isDebugTest;
 describe('Queue Operation Test', () => {
   it('should validate a queue', () => {
     const queue = new Queue<number>();
@@ -84,7 +86,7 @@ describe('Queue', () => {
     queue.push(2);
     expect(queue.size).toBe(2);
     expect(queue.peek()).toBe(1);
-    expect(queue.peekLast()).toBe(2);
+    expect(queue.getLast()).toBe(2);
   });
 
   it('should shift elements from the front of the queue', () => {
@@ -94,7 +96,7 @@ describe('Queue', () => {
     expect(shifted).toBe(1);
     expect(queue.size).toBe(1);
     expect(queue.peek()).toBe(2);
-    expect(queue.peekLast()).toBe(2);
+    expect(queue.getLast()).toBe(2);
   });
 
   it('should handle shifting when queue reaches half size', () => {
@@ -115,7 +117,7 @@ describe('Queue', () => {
     queue.push(1);
     queue.push(2);
     expect(queue.peek()).toBe(1);
-    expect(queue.peekLast()).toBe(2);
+    expect(queue.getLast()).toBe(2);
   });
 
   it('should handle shifting when the queue is empty', () => {
@@ -127,7 +129,7 @@ describe('Queue', () => {
 
   it('should handle peeking when the queue is empty', () => {
     expect(queue.peek()).toBeUndefined();
-    expect(queue.peekLast()).toBeUndefined();
+    expect(queue.getLast()).toBeUndefined();
   });
 
   it('should handle clearing the queue', () => {
@@ -137,7 +139,7 @@ describe('Queue', () => {
     queue.clear();
     expect(queue.size).toBe(0);
     expect(queue.peek()).toBeUndefined();
-    expect(queue.peekLast()).toBeUndefined();
+    expect(queue.getLast()).toBeUndefined();
   });
 
   it('should clone the queue', () => {
@@ -147,7 +149,7 @@ describe('Queue', () => {
     const clonedQueue = queue.clone();
     expect(clonedQueue.size).toBe(3);
     expect(clonedQueue.peek()).toBe(1);
-    expect(clonedQueue.peekLast()).toBe(3);
+    expect(clonedQueue.getLast()).toBe(3);
   });
 
   it('should handle creating a queue from an array', () => {
@@ -155,7 +157,7 @@ describe('Queue', () => {
     const newQueue = Queue.fromArray(elements);
     expect(newQueue.size).toBe(5);
     expect(newQueue.peek()).toBe(1);
-    expect(newQueue.peekLast()).toBe(5);
+    expect(newQueue.getLast()).toBe(5);
   });
 
   it('should iterate through the queue', () => {
@@ -197,3 +199,45 @@ describe('LinkedListQueue', () => {
 
   // Add more test cases for other methods of LinkedListQueue.
 });
+
+describe('Queue Performance Test', () => {
+  const dataSize = 10000;
+  it('should numeric queue be efficient', function () {
+    const startTime = performance.now();
+    const queue = new Queue<number>();
+    for (let i = 0; i < dataSize; i++) {
+      queue.enqueue(i);
+    }
+    for (let i = 0; i < dataSize; i++) {
+      queue.dequeue();
+    }
+    isDebug && console.log(`Queue Performance Test: ${performance.now() - startTime} ms`);
+    expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
+  });
+
+  it('should numeric Array be more efficient than Queue when the data size is 10000', function () {
+    const startTime2 = performance.now();
+    const queue2: number[] = [];
+    for (let i = 0; i < dataSize; i++) {
+      queue2.push(i);
+    }
+    for (let i = 0; i < dataSize; i++) {
+      queue2.shift();
+    }
+    console.log(`Array Performance Test: ${performance.now() - startTime2} ms`);
+    expect(performance.now() - startTime2).toBeLessThan(bigO.CUBED * 100);
+  });
+
+  it('should numeric LinkedListQueue be efficient', function () {
+    const startTime = performance.now();
+    const queue = new LinkedListQueue<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`);
+    expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
+  });
+});

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

@@ -29,11 +29,11 @@ describe('TreeNode', () => {
     child1.addChildren([grandchild1]);
     child2.addChildren([grandchild2]);
 
-    expect(rootNode.getHeight()).toBe(3); // Height of the tree should be 3
+    expect(rootNode.getHeight()).toBe(2); // Height of the tree should be 2
   });
 
   it('should handle nodes without children when calculating height', () => {
     const rootNode = new TreeNode<string>('1', 'Root Node');
-    expect(rootNode.getHeight()).toBe(1); // Height of a single node should be 1
+    expect(rootNode.getHeight()).toBe(0); // Height of a single node should be 0
   });
 });