data-structure-typed 1.50.1 → 1.50.3

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

@@ -1,4 +1,4 @@
-import { FibonacciHeap, MaxHeap, MinHeap } from '../../../../src';
+import { FibonacciHeap, Heap, MaxHeap, MinHeap } from '../../../../src';
 import { logBigOMetricsWrap } from '../../../utils';
 
 describe('Heap Operation Test', () => {
@@ -26,6 +26,23 @@ describe('Heap Operation Test', () => {
     expect(minNumHeap.sort()).toEqual([2, 5, 6, 9]);
   });
 
+  it('should clone', function () {
+    const minNumHeap = new Heap<string>([], { comparator: (a, b) => Number(a) - Number(b) });
+    minNumHeap.add('1');
+    minNumHeap.add('6');
+    minNumHeap.add('2');
+    minNumHeap.add('0');
+    minNumHeap.add('5');
+    minNumHeap.add('9');
+    minNumHeap.delete('2');
+    expect([...minNumHeap]).toEqual(['0', '1', '9', '6', '5']);
+    const cloned = minNumHeap.clone();
+    expect([...cloned]).toEqual(['0', '1', '9', '6', '5']);
+    minNumHeap.delete('5');
+    expect([...minNumHeap]).toEqual(['0', '1', '9', '6']);
+    expect([...cloned]).toEqual(['0', '1', '9', '6', '5']);
+  });
+
   it('should object heap work well', function () {
     const minHeap = new MinHeap<{ a: string; key: number }>([], { comparator: (a, b) => a.key - b.key });
     minHeap.add({ key: 1, a: 'a1' });

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

@@ -37,8 +37,27 @@ describe('DoublyLinkedList Operation Test', () => {
     expect(list.tail?.value).toBe(4);
   });
 
+  it('should clone', function () {
+    const dList = new DoublyLinkedList<string>();
+    dList.addLast('1');
+    dList.addLast('6');
+    dList.addLast('2');
+    dList.addLast('0');
+    dList.addLast('5');
+    dList.addLast('9');
+    dList.delete('2');
+    expect([...dList]).toEqual(['1', '6', '0', '5', '9']);
+    const cloned = dList.clone();
+    expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
+    dList.delete('5');
+    expect([...dList]).toEqual(['1', '6', '0', '9']);
+    expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
+  });
+
   it('should find undefined', () => {
     expect(list.find(value => value === 6)).toBe(undefined);
+    expect(list.find(value => value === 4)).toBe(4);
+    expect(list.find(value => value === 3)).toBe(3);
   });
 
   it('should indexOf -1', () => {
@@ -99,19 +118,19 @@ describe('DoublyLinkedList Operation Test', () => {
     // Inserting at the beginning
     list.addAt(0, 0);
     expect(list.size).toBe(4);
-    expect(list.getAt(0)).toBe(0);
-    expect(list.getAt(1)).toBe(1);
+    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.getAt(2)).toBe(1.5);
-    expect(list.getAt(3)).toBe(2);
+    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.getAt(5)).toBe(4);
+    expect(list.at(5)).toBe(4);
     expect(list.tail!.value).toBe(4);
   });
 

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

@@ -72,14 +72,14 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(1);
       list.push(2);
       list.push(3);
-      const element = list.getAt(1);
+      const element = list.at(1);
       expect(element).toBe(2);
       expect(list.getNodeAt(2)?.value).toBe(3);
     });
 
     it('should return undefined for an out-of-bounds index', () => {
       list.push(1);
-      const element = list.getAt(1);
+      const element = list.at(1);
       expect(element).toBeUndefined();
     });
   });
@@ -327,6 +327,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(3);
       const result = list.find(data => data % 2 === 0);
       expect(result).toBe(2);
+      expect(list.find(value => value === 3)).toBe(3);
     });
 
     it('should return undefined if element is not found', () => {
@@ -347,6 +348,23 @@ describe('SinglyLinkedList Operation Test', () => {
     });
   });
 
+  it('should clone', function () {
+    const sList = new SinglyLinkedList<string>();
+    sList.addLast('1');
+    sList.addLast('6');
+    sList.addLast('2');
+    sList.addLast('0');
+    sList.addLast('5');
+    sList.addLast('9');
+    sList.delete('2');
+    expect([...sList]).toEqual(['1', '6', '0', '5', '9']);
+    const cloned = sList.clone();
+    expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
+    sList.delete('5');
+    expect([...sList]).toEqual(['1', '6', '0', '9']);
+    expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
+  });
+
   describe('countOccurrences', () => {
     it('should count occurrences of a value', () => {
       list.push(1);

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

@@ -54,7 +54,7 @@ describe('SkipList', () => {
   });
 });
 
-describe('SkipList', () => {
+describe('SkipList Test2', () => {
   let skipList: SkipList<number, string>;
 
   beforeEach(() => {

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

@@ -40,14 +40,42 @@ describe('Deque - Basic Operations', () => {
     expect(deque.isEmpty()).toBeTruthy();
   });
 
-  test('getAt should retrieve the correct element', () => {
-    expect(deque.getAt(0)).toBe(1);
-    expect(deque.getAt(1)).toBe(2);
+  test('at should retrieve the correct element', () => {
+    expect(deque.at(0)).toBe(1);
+    expect(deque.at(1)).toBe(2);
   });
 
   test('setAt should set the correct element', () => {
     deque.setAt(0, 3);
-    expect(deque.getAt(0)).toBe(3);
+    expect(deque.at(0)).toBe(3);
+  });
+
+  it('should clone', function () {
+    const deque = new Deque<string>();
+    deque.addLast('1');
+    deque.addLast('6');
+    deque.addLast('2');
+    deque.addLast('0');
+    deque.addLast('5');
+    deque.addLast('9');
+    expect(deque.size).toBe(6);
+    deque.delete('2');
+    expect(deque.size).toBe(5);
+    expect([...deque]).toEqual(['1', '6', '0', '5', '9']);
+    const cloned = deque.clone();
+    expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
+    expect(deque.size).toBe(5);
+    deque.delete('5');
+    expect(deque.size).toBe(4);
+    expect([...deque]).toEqual(['1', '6', '0', '9']);
+    expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
+    expect(cloned.size).toBe(5);
+    cloned.addLast('8');
+    expect(cloned.size).toBe(6);
+    cloned.delete('6');
+    expect(cloned.size).toBe(5);
+    cloned.delete('6');
+    expect(cloned.size).toBe(5);
   });
 });
 describe('Deque - Complex Operations', () => {
@@ -68,8 +96,40 @@ describe('Deque - Complex Operations', () => {
     deque.push(1);
     deque.push(2);
     deque.push(3);
-    deque.cut(1);
+    expect(deque.size).toBe(3);
+    deque.cut(1, true);
+    expect(deque.size).toBe(2);
     expect(deque.toArray()).toEqual([1, 2]);
+
+    const dq1 = new Deque([1, 2, 3, 4, 5, 6, 7]);
+    expect(dq1.size).toBe(7);
+    expect([...dq1.cut(3, true)]).toEqual([1, 2, 3, 4]);
+    expect(dq1.size).toBe(4);
+    expect([...dq1]).toEqual([1, 2, 3, 4]);
+  });
+
+  test('cutRest should remove elements after the specified position', () => {
+    deque.push(1);
+    deque.push(2);
+    deque.push(3);
+    deque.cutRest(1, true);
+    expect(deque.toArray()).toEqual([2, 3]);
+
+    const dq = new Deque([1, 2, 3, 4, 5, 6, 7]);
+    expect([...dq.cutRest(3, true)]).toEqual([4, 5, 6, 7]);
+    expect([...dq]).toEqual([4, 5, 6, 7]);
+
+    const deque1 = new Deque<number>();
+
+    deque1.push(1);
+    deque1.push(2);
+    deque1.push(3);
+    expect(deque1.toArray()).toEqual([1, 2, 3]);
+    expect(deque1.cutRest(1).toArray()).toEqual([2, 3]);
+
+    const dq1 = new Deque([1, 2, 3, 4, 5, 6, 7]);
+    expect([...dq1.cutRest(3)]).toEqual([4, 5, 6, 7]);
+    expect([...dq1]).toEqual([1, 2, 3, 4, 5, 6, 7]);
   });
 
   test('deleteAt should remove the element at the specified position', () => {

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

@@ -89,6 +89,25 @@ describe('Queue', () => {
     }
     expect(queue.isEmpty()).toBeTruthy();
   });
+
+  it('should clone', function () {
+    const queue = new Queue<string>();
+    queue.push('1');
+    queue.push('6');
+    queue.push('2');
+    queue.push('0');
+    queue.push('5');
+    queue.push('9');
+    queue.delete('2');
+    expect([...queue]).toEqual(['1', '6', '0', '5', '9']);
+    const cloned = queue.clone();
+    expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
+    queue.delete('5');
+    expect([...queue]).toEqual(['1', '6', '0', '9']);
+    queue.deleteAt(2);
+    expect([...queue]).toEqual(['1', '6', '9']);
+    expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
+  });
 });
 
 describe('Queue - Advanced Methods', () => {
@@ -156,17 +175,17 @@ describe('Queue - Additional Methods', () => {
     expect(queue.peekLast()).toBeUndefined();
   });
 
-  test('getAt should return the element at the specified index', () => {
+  test('at should return the element at the specified index', () => {
     queue.push(1);
     queue.push(2);
     queue.push(3);
-    expect(queue.getAt(1)).toBe(2);
+    expect(queue.at(1)).toBe(2);
   });
 
-  test('getAt should return undefined for an invalid index', () => {
+  test('at should return undefined for an invalid index', () => {
     queue.push(1);
-    expect(queue.getAt(3)).toBeUndefined();
-    expect(queue.getAt(-1)).toBeUndefined();
+    expect(queue.at(3)).toBeUndefined();
+    expect(queue.at(-1)).toBeUndefined();
   });
 
   test('print should not throw any errors', () => {

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

@@ -35,6 +35,23 @@ describe('Stack', () => {
     expect(stack.size).toBe(2);
   });
 
+  it('should clone', function () {
+    const stack = new Stack<string>();
+    stack.push('1');
+    stack.push('6');
+    stack.push('2');
+    stack.push('0');
+    stack.push('5');
+    stack.push('9');
+    stack.delete('2');
+    expect([...stack]).toEqual(['1', '6', '0', '5', '9']);
+    const cloned = stack.clone();
+    expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
+    stack.delete('5');
+    expect([...stack]).toEqual(['1', '6', '0', '9']);
+    expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
+  });
+
   it('should return undefined when popping from an empty stack', () => {
     const poppedElement = stack.pop();
     expect(poppedElement).toBe(undefined);

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

@@ -56,6 +56,23 @@ describe('Trie', () => {
     expect(trie.hasPrefix('banana')).toBe(false);
   });
 
+  it('should clone', function () {
+    const trie = new Trie();
+    trie.add('1');
+    trie.add('6');
+    trie.add('2');
+    trie.add('0');
+    trie.add('5');
+    trie.add('9');
+    trie.delete('2');
+    expect([...trie]).toEqual(['1', '6', '0', '5', '9']);
+    const cloned = trie.clone();
+    expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
+    trie.delete('5');
+    expect([...trie]).toEqual(['1', '6', '0', '9']);
+    expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
+  });
+
   it('should check if a string is a common prefix', () => {
     const trie = new Trie();
     trie.add('apple');