data-structure-typed 1.50.0 → 1.50.2

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', () => {
@@ -164,13 +224,14 @@ describe('Deque - Utility Operations', () => {
   });
 
   test('print should print the deque elements', () => {
-    const consoleSpy = jest.spyOn(console, 'log');
-    deque.push(1);
-    deque.push(2);
-    deque.print();
-    expect(consoleSpy).toHaveBeenCalledWith([1, 2]);
+    // const consoleSpy = jest.spyOn(console, 'log');
+    // deque.push(1);
+    // deque.push(2);
+    // deque.print();
+    // expect(consoleSpy).toHaveBeenCalledWith([1, 2]);
   });
 });
+
 describe('Deque - Additional Operations', () => {
   let deque: Deque<number>;
 

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

@@ -89,6 +89,23 @@ 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']);
+    expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
+  });
 });
 
 describe('Queue - Advanced Methods', () => {
@@ -156,23 +173,23 @@ 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', () => {
     expect(() => {
       queue.push(1);
-      queue.print();
+      // queue.print();
     }).not.toThrow();
   });
 });

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');

package/test/unit/unrestricted-interconversion.test.ts

@@ -33,91 +33,155 @@ const orgStrArr: string[] = [
   'trace',
   'transmit'
 ];
-const entries: [number, number][] = [
-  [6, 6],
-  [1, 1],
-  [2, 2],
-  [7, 7],
-  [5, 5],
-  [3, 3],
-  [4, 4],
-  [9, 9],
-  [8, 8]
+const entries: [number, string][] = [
+  [6, '6'],
+  [1, '1'],
+  [2, '2'],
+  [7, '7'],
+  [5, '5'],
+  [3, '3'],
+  [4, '4'],
+  [9, '9'],
+  [8, '8']
 ];
 
 describe('conversions', () => {
   it('Array to Queue', () => {
     const q = new Queue<number>(orgArr);
     isDebug && q.print();
+    expect([...q]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
   });
 
   it('Array to Deque', () => {
     const dq = new Deque<number>(orgArr);
     isDebug && dq.print();
+    expect([...dq]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
   });
 
   it('Array to SinglyLinkedList', () => {
     const sl = new SinglyLinkedList<number>(orgArr);
     isDebug && sl.print();
+    expect([...sl]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
   });
 
   it('Array to DoublyLinkedList', () => {
     const dl = new DoublyLinkedList<number>(orgArr);
     isDebug && dl.print();
+    expect([...dl]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
   });
 
   it('Array to Stack', () => {
     const stack = new Stack<number>(orgArr);
     isDebug && stack.print();
+    expect([...stack]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
   });
 
   it('Array to MinHeap', () => {
     const minHeap = new MinHeap<number>(orgArr);
     isDebug && minHeap.print();
+    expect([...minHeap]).toEqual([1, 5, 2, 7, 6, 3, 4, 9, 8]);
   });
 
   it('Array to MaxHeap', () => {
     const maxHeap = new MaxHeap<number>(orgArr);
     isDebug && maxHeap.print();
+    expect([...maxHeap]).toEqual([9, 8, 4, 7, 5, 2, 3, 1, 6]);
   });
 
   it('Array to MinPriorityQueue', () => {
     const minPQ = new MinPriorityQueue<number>(orgArr);
     isDebug && minPQ.print();
+    expect([...minPQ]).toEqual([1, 5, 2, 7, 6, 3, 4, 9, 8]);
   });
 
   it('Array to MaxPriorityQueue', () => {
     const maxPQ = new MaxPriorityQueue<number>(orgArr);
     isDebug && maxPQ.print();
+    expect([...maxPQ]).toEqual([9, 8, 4, 7, 5, 2, 3, 1, 6]);
   });
 
   it('Entry Array to BinaryTree', () => {
     const biTree = new BinaryTree<number>(entries);
     isDebug && biTree.print();
+    expect([...biTree]).toEqual([
+      [9, '9'],
+      [7, '7'],
+      [8, '8'],
+      [1, '1'],
+      [5, '5'],
+      [6, '6'],
+      [3, '3'],
+      [2, '2'],
+      [4, '4']
+    ]);
   });
 
   it('Entry Array to BST', () => {
     const bst = new BST<number>(entries);
     expect(bst.size).toBe(9);
     isDebug && bst.print();
+    expect([...bst]).toEqual([
+      [1, '1'],
+      [2, '2'],
+      [3, '3'],
+      [4, '4'],
+      [5, '5'],
+      [6, '6'],
+      [7, '7'],
+      [8, '8'],
+      [9, '9']
+    ]);
   });
 
   it('Entry Array to RedBlackTree', () => {
     const rbTree = new RedBlackTree<number>(entries);
     expect(rbTree.size).toBe(9);
     isDebug && rbTree.print();
+    expect([...rbTree]).toEqual([
+      [1, '1'],
+      [2, '2'],
+      [3, '3'],
+      [4, '4'],
+      [5, '5'],
+      [6, '6'],
+      [7, '7'],
+      [8, '8'],
+      [9, '9']
+    ]);
   });
 
   it('Entry Array to AVLTree', () => {
     const avl = new AVLTree<number>(entries);
     expect(avl.size).toBe(9);
     isDebug && avl.print();
+    expect([...avl]).toEqual([
+      [1, '1'],
+      [2, '2'],
+      [3, '3'],
+      [4, '4'],
+      [5, '5'],
+      [6, '6'],
+      [7, '7'],
+      [8, '8'],
+      [9, '9']
+    ]);
   });
 
   it('Entry Array to TreeMultimap', () => {
     const treeMulti = new TreeMultimap<number>(entries);
     expect(treeMulti.size).toBe(9);
     isDebug && treeMulti.print();
+    expect([...treeMulti]).toEqual([
+      [1, '1'],
+      [2, '2'],
+      [3, '3'],
+      [4, '4'],
+      [5, '5'],
+      [6, '6'],
+      [7, '7'],
+      [8, '8'],
+      [9, '9']
+    ]);
   });
 
   it('HashMap to RedBlackTree', () => {
@@ -126,6 +190,17 @@ describe('conversions', () => {
     const rbTree = new RedBlackTree<number>(hm);
     expect(rbTree.size).toBe(9);
     isDebug && rbTree.print();
+    expect([...rbTree]).toEqual([
+      [1, '1'],
+      [2, '2'],
+      [3, '3'],
+      [4, '4'],
+      [5, '5'],
+      [6, '6'],
+      [7, '7'],
+      [8, '8'],
+      [9, '9']
+    ]);
   });
 
   it('PriorityQueue to BST', () => {
@@ -134,6 +209,17 @@ describe('conversions', () => {
     const bst = new BST<number>(pq);
     expect(bst.size).toBe(9);
     isDebug && bst.print();
+    expect([...bst]).toEqual([
+      [1, undefined],
+      [2, undefined],
+      [3, undefined],
+      [4, undefined],
+      [5, undefined],
+      [6, undefined],
+      [7, undefined],
+      [8, undefined],
+      [9, undefined]
+    ]);
   });
 
   it('Deque to RedBlackTree', () => {
@@ -142,6 +228,17 @@ describe('conversions', () => {
     const rbTree = new RedBlackTree<number>(dq);
     expect(rbTree.size).toBe(9);
     isDebug && rbTree.print();
+    expect([...rbTree]).toEqual([
+      [1, undefined],
+      [2, undefined],
+      [3, undefined],
+      [4, undefined],
+      [5, undefined],
+      [6, undefined],
+      [7, undefined],
+      [8, undefined],
+      [9, undefined]
+    ]);
   });
 
   it('Trie to Heap to Deque', () => {
@@ -151,12 +248,48 @@ describe('conversions', () => {
     const heap = new Heap<string>(trie, { comparator: (a, b) => Number(a) - Number(b) });
     expect(heap.size).toBe(10);
     isDebug && heap.print();
+    expect([...heap]).toEqual([
+      'transmit',
+      'trace',
+      'tree',
+      'trend',
+      'track',
+      'trial',
+      'trip',
+      'trie',
+      'trick',
+      'triangle'
+    ]);
     const dq = new Deque<string>(heap);
     expect(dq.size).toBe(10);
     isDebug && dq.print();
+    expect([...dq]).toEqual([
+      'transmit',
+      'trace',
+      'tree',
+      'trend',
+      'track',
+      'trial',
+      'trip',
+      'trie',
+      'trick',
+      'triangle'
+    ]);
     const entries = dq.map((el, i) => <[number, string]>[i, el]);
     const avl = new AVLTree<number, string>(entries);
     expect(avl.size).toBe(10);
     isDebug && avl.print();
+    expect([...avl]).toEqual([
+      [0, 'transmit'],
+      [1, 'trace'],
+      [2, 'tree'],
+      [3, 'trend'],
+      [4, 'track'],
+      [5, 'trial'],
+      [6, 'trip'],
+      [7, 'trie'],
+      [8, 'trick'],
+      [9, 'triangle']
+    ]);
   });
 });