data-structure-typed 1.49.1 → 1.49.3

package/src/data-structures/trie/trie.ts

@@ -138,7 +138,7 @@ export class Trie extends IterableElementBase<string> {
    * @param{string} word - The word to delete.
    * @returns {boolean} True if the word was successfully removed.
    */
-  delete(word: string) {
+  delete(word: string): boolean {
     word = this._caseProcess(word);
     let isDeleted = false;
     const dfs = (cur: TrieNode, i: number): boolean => {
@@ -184,7 +184,7 @@ export class Trie extends IterableElementBase<string> {
    * Space Complexity: O(1) - Constant space.
    *
    */
-  getHeight() {
+  getHeight(): number {
     const beginRoot = this.root;
     let maxDepth = 0;
     if (beginRoot) {
@@ -371,12 +371,12 @@ export class Trie extends IterableElementBase<string> {
    * specific object as the context for the `predicate` function. If `thisArg` is provided, it will be
    * @returns The `filter` method is returning an array of strings (`string[]`).
    */
-  filter(predicate: ElementCallback<string, boolean>, thisArg?: any): string[] {
-    const results: string[] = [];
+  filter(predicate: ElementCallback<string, boolean>, thisArg?: any): Trie {
+    const results: Trie = new Trie();
     let index = 0;
     for (const word of this) {
       if (predicate.call(thisArg, word, index, this)) {
-        results.push(word);
+        results.add(word);
       }
       index++;
     }
@@ -411,10 +411,6 @@ export class Trie extends IterableElementBase<string> {
     return newTrie;
   }
 
-  print() {
-    console.log([...this]);
-  }
-
   protected* _getIterator(): IterableIterator<string> {
     function* _dfs(node: TrieNode, path: string): IterableIterator<string> {
       if (node.isEnd) {

package/test/performance/data-structures/comparison/comparison.test.ts

@@ -47,23 +47,23 @@ if (isCompetitor) {
 }
 
 suite
-  .add(`SRC PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
+  .add(`SRC PQ ${TEN_THOUSAND.toLocaleString()} add & poll`, () => {
     const pq = new SRCPriorityQueue<number>([], { comparator: (a, b) => b - a });
 
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
-    for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();
+    for (let i = 0; i < TEN_THOUSAND; i++) pq.poll();
   })
-  .add(`CJS PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
+  .add(`CJS PQ ${TEN_THOUSAND.toLocaleString()} add & poll`, () => {
     const pq = new CJSPriorityQueue<number>([], { comparator: (a, b) => b - a });
 
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
-    for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();
+    for (let i = 0; i < TEN_THOUSAND; i++) pq.poll();
   })
-  .add(`MJS PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
+  .add(`MJS PQ ${TEN_THOUSAND.toLocaleString()} add & poll`, () => {
     const pq = new MJSPriorityQueue<number>([], { comparator: (a, b) => b - a });
 
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
-    for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();
+    for (let i = 0; i < TEN_THOUSAND; i++) pq.poll();
   });
 
 

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

@@ -6,7 +6,7 @@ const suite = new Benchmark.Suite();
 const { HUNDRED_THOUSAND, TEN_THOUSAND } = magnitude;
 
 suite
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
     const heap = new Heap<number>([], { comparator: (a, b) => b - a });
 
     for (let i = 0; i < HUNDRED_THOUSAND; i++) {
@@ -14,7 +14,7 @@ suite
     }
 
     for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      heap.pop();
+      heap.poll();
     }
   })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} add & dfs`, () => {

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

@@ -55,7 +55,7 @@ suite
       list.shift();
     }
   })
-  .add(`${LINEAR.toLocaleString()} insertBefore`, () => {
+  .add(`${LINEAR.toLocaleString()} addBefore`, () => {
     const doublyList = new DoublyLinkedList<number>();
     let midNode: DoublyLinkedListNode | undefined;
     const midIndex = Math.floor(LINEAR / 2);
@@ -64,7 +64,7 @@ suite
       if (i === midIndex) {
         midNode = doublyList.getNode(i);
       } else if (i > midIndex && midNode) {
-        doublyList.insertBefore(midNode, i);
+        doublyList.addBefore(midNode, i);
       }
     }
   });

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

@@ -28,7 +28,7 @@ suite
       list.pop();
     }
   })
-  .add(`${TEN_THOUSAND.toLocaleString()} insertBefore`, () => {
+  .add(`${TEN_THOUSAND.toLocaleString()} addBefore`, () => {
     const singlyList = new SinglyLinkedList<number>();
     let midSinglyNode: SinglyLinkedListNode | undefined;
     const midIndex = Math.floor(TEN_THOUSAND / 2);
@@ -37,7 +37,7 @@ suite
       if (i === midIndex) {
         midSinglyNode = singlyList.getNode(i);
       } else if (i > midIndex && midSinglyNode) {
-        singlyList.insertBefore(midSinglyNode.value, i);
+        singlyList.addBefore(midSinglyNode.value, i);
       }
     }
   });

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

@@ -7,7 +7,7 @@ import { isCompetitor } from '../../../config';
 const suite = new Benchmark.Suite();
 const { HUNDRED_THOUSAND } = magnitude;
 
-suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
+suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
   const pq = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
 
   for (let i = 0; i < HUNDRED_THOUSAND; i++) {
@@ -15,7 +15,7 @@ suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
   }
 
   for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-    pq.pop();
+    pq.poll();
   }
 });
 if (isCompetitor) {

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

@@ -1,8 +1,8 @@
 import { BinaryTree, BinaryTreeNode, FamilyPosition, IterationType } from '../../../../src';
 import { getRandomIntArray } from '../../../utils';
-import { isDebugTest } from '../../../config';
+// import { isDebugTest } from '../../../config';
 
-const isDebug = isDebugTest;
+// const isDebug = isDebugTest;
 
 describe('BinaryTreeNode', () => {
   it('should create an instance of BinaryTreeNode', () => {

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

@@ -66,7 +66,7 @@ class MyGraph<
     return edge ? undefined : undefined;
   }
 
-  protected _addEdgeOnly(edge: EO): boolean {
+  protected _addEdge(edge: EO): boolean {
     return edge ? true : true;
   }
 }

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

@@ -588,7 +588,7 @@ describe('cycles, strongly connected components, bridges, articular points in Di
   const cutVertexes = graph.getCutVertexes();
   const dfnMap = graph.getDFNMap();
   const lowMap = graph.getLowMap();
-  expect(cycles.size).toBe(2);
+  expect(cycles.length).toBe(2);
   expect(scCs.size).toBe(5);
   expect(bridges.length).toBe(4);
   expect(cutVertexes.length).toBe(4);
@@ -688,8 +688,53 @@ describe('DirectedGraph getCycles', () => {
     graph.addEdge('D', 'E');
     graph.addEdge('E', 'B');
     const cycles = graph.getCycles();
-    expect(cycles.size).toBe(1);
-    expect(cycles.get(2)).toEqual( [{ "key": "B", "value": undefined }, { "key": "D", "value": undefined }, { "key": "E", "value": undefined }]);
+    expect(cycles.length).toBe(1);
+    expect(cycles[0]).toEqual(["B", "D", "E"]);
   })
+
+  test('should simple cycles graph getCycles return correct result', () => {
+    const graph = new DirectedGraph();
+
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'C');
+    graph.addEdge('C', 'A');
+    graph.addEdge('A', 'D');
+    graph.addEdge('D', 'C');
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(2)
+    expect(cycles).toEqual([["A", "B", "C"], ["A", "D", "C"]])
+  });
+
+  test('should 3 cycles graph getCycles return correct result', () => {
+    const graph = new DirectedGraph();
+
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+    graph.addVertex('E');
+    graph.addVertex('F');
+    graph.addVertex('G');
+
+    graph.addEdge('A', 'B');
+    graph.addEdge('A', 'C');
+    graph.addEdge('B', 'D');
+    graph.addEdge('C', 'D');
+    graph.addEdge('D', 'E');
+    graph.addEdge('E', 'B');
+    graph.addEdge('B', 'F');
+    graph.addEdge('F', 'E');
+    graph.addEdge('C', 'G');
+    graph.addEdge('G', 'A');
+
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(3)
+    expect(cycles).toEqual([["A", "C", "G"], ["B", "D", "E"], ["B", "F", "E"]]);
+  });
 })
 

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

@@ -237,7 +237,7 @@ describe('cycles, strongly connected components, bridges, articular points in Un
   const cutVertexes = graph.getCutVertexes();
   const dfnMap = graph.getDFNMap();
   const lowMap = graph.getLowMap();
-  expect(cycles.size).toBe(2);
+  expect(cycles.length).toBe(3);
   expect(scCs.size).toBe(5);
   expect(bridges.length).toBe(4);
   expect(cutVertexes.length).toBe(4);
@@ -277,8 +277,52 @@ describe('UndirectedGraph getCycles', () => {
     graph.addEdge('D', 'E');
     graph.addEdge('E', 'B');
     const cycles = graph.getCycles();
-    expect(cycles.size).toBe(2);
-    expect(cycles.get(1)).toEqual([{ "key": "A", "value": "A" }, { "key": "B", "value": "B" }, { "key": "D", "value": "D" }, { "key": "C", "value": "C" }]);
-    expect(cycles.get(2)).toEqual([{ "key": "B", "value": "B" }, { "key": "D", "value": "D" }, { "key": "E", "value": "E" }]);
+    expect(cycles.length).toBe(3);
+    expect(cycles).toEqual([["A", "B", "D", "C"], ["A", "B", "E", "D", "C"], ["B", "D", "E"]]);
   })
+
+  test('should simple cycles graph getCycles return correct result', () => {
+    const graph = new UndirectedGraph();
+
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'C');
+    graph.addEdge('C', 'A');
+    graph.addEdge('A', 'D');
+    graph.addEdge('D', 'C');
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(3)
+    expect(cycles).toEqual([["A", "B", "C"], ["A", "B", "C", "D"], ["A", "C", "D"]])
+  });
+
+  test('should 3 cycles graph getCycles return correct result', () => {
+    const graph = new UndirectedGraph();
+
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+    graph.addVertex('E');
+    graph.addVertex('F');
+    graph.addVertex('G');
+
+    graph.addEdge('A', 'B');
+    graph.addEdge('A', 'C');
+    graph.addEdge('B', 'D');
+    graph.addEdge('C', 'D');
+    graph.addEdge('D', 'E');
+    graph.addEdge('E', 'B');
+    graph.addEdge('B', 'F');
+    graph.addEdge('F', 'E');
+    graph.addEdge('C', 'G');
+    graph.addEdge('G', 'A');
+
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(10)
+    expect(cycles).toEqual([["A", "B", "D", "C"], ["A", "B", "D", "C", "G"], ["A", "B", "E", "D", "C"], ["A", "B", "E", "D", "C", "G"], ["A", "B", "F", "E", "D", "C"], ["A", "B", "F", "E", "D", "C", "G"], ["A", "C", "G"], ["B", "D", "E"], ["B", "D", "E", "F"], ["B", "E", "F"]]);
+  });
 })

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

@@ -453,7 +453,7 @@ describe('LinkedHashMap Test2', () => {
         expect(hashMap.last).toEqual([key, value]);
         expect(hashMap.reverseBegin().next().value).toEqual([key, value]);
       } else if (index <= 1000) {
-        expect(hashMap.getAt(index)).toEqual([key, value]);
+        expect(hashMap.getAt(index)).toBe(value);
       }
       expect(hashMap.get(key)).toEqual(value);
       index++;
@@ -502,7 +502,7 @@ describe('LinkedHashMap Test2', () => {
   test('should get element at specific index', () => {
     hashMap.set('key1', 'value1');
     hashMap.set('key2', 'value2');
-    expect(hashMap.getAt(1)).toEqual(['key2', 'value2']);
+    expect(hashMap.getAt(1)).toBe('value2');
   });
 });
 

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

@@ -5,7 +5,12 @@ import { logBigOMetricsWrap } from '../../../utils';
 describe('Heap Operation Test', () => {
   it('should numeric heap work well', function () {
     const minNumHeap = new MinHeap<number>();
-    minNumHeap.add(1).add(6).add(2).add(0).add(5).add(9);
+    minNumHeap.add(1);
+    minNumHeap.add(6);
+    minNumHeap.add(2);
+    minNumHeap.add(0);
+    minNumHeap.add(5);
+    minNumHeap.add(9);
     expect(minNumHeap.has(1)).toBe(true);
     expect(minNumHeap.has(2)).toBe(true);
     expect(minNumHeap.poll()).toBe(0);

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

@@ -55,7 +55,7 @@ describe('MinHeap', () => {
 
   it('should push & dfs', () => {
     for (let i = 0; i < n; i++) {
-      minHeap.push(i);
+      minHeap.add(i);
     }
     expect(minHeap.dfs()[0]).toBe(0)
     expect(minHeap.dfs()[999]).toBe(4126)

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

@@ -19,11 +19,11 @@ describe('DoublyLinkedList Operation Test', () => {
   it('should out of bound index', () => {
     expect(list.getNodeAt(-1)).toBe(undefined);
     expect(list.getNodeAt(5)).toBe(undefined);
-    expect(list.insertAt(5, 6)).toBe(true);
+    expect(list.addAt(5, 6)).toBe(true);
   });
 
-  it('should insertBefore', () => {
-    expect(list.insertBefore(1, 0)).toBe(true);
+  it('should addBefore', () => {
+    expect(list.addBefore(1, 0)).toBe(true);
   });
 
   it('should deleteAt', () => {
@@ -49,11 +49,11 @@ describe('DoublyLinkedList Operation Test', () => {
     expect(list.findBackward(value => value === 0)).toBe(undefined);
   });
 
-  it('should insertAfter tail', () => {
-    expect(list.insertAfter(list.tail!, 6)).toBe(true);
+  it('should addAfter tail', () => {
+    expect(list.addAfter(list.tail!, 6)).toBe(true);
   });
 
-  it('should insertAfter tail', () => {
+  it('should addAfter tail', () => {
     expect([...list]).toEqual([1, 2, 3, 4, 5]);
   });
 });
@@ -68,7 +68,7 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should initialize an empty list', () => {
-    expect(list.length).toBe(0);
+    expect(list.size).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -77,7 +77,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(1);
     list.push(2);
     list.push(3);
-    expect(list.length).toBe(3);
+    expect(list.size).toBe(3);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(3);
   });
@@ -87,7 +87,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     const poppedValue = list.pop();
     expect(poppedValue).toBe(2);
-    expect(list.length).toBe(1);
+    expect(list.size).toBe(1);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(1);
   });
@@ -97,20 +97,20 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
 
     // Inserting at the beginning
-    list.insertAt(0, 0);
-    expect(list.length).toBe(4);
+    list.addAt(0, 0);
+    expect(list.size).toBe(4);
     expect(list.getAt(0)).toBe(0);
     expect(list.getAt(1)).toBe(1);
 
     // Inserting in the middle
-    list.insertAt(2, 1.5);
-    expect(list.length).toBe(5);
+    list.addAt(2, 1.5);
+    expect(list.size).toBe(5);
     expect(list.getAt(2)).toBe(1.5);
     expect(list.getAt(3)).toBe(2);
 
     // Inserting at the end
-    list.insertAt(5, 4);
-    expect(list.length).toBe(6);
+    list.addAt(5, 4);
+    expect(list.size).toBe(6);
     expect(list.getAt(5)).toBe(4);
     expect(list.tail!.value).toBe(4);
   });
@@ -122,18 +122,18 @@ describe('DoublyLinkedList Operation Test', () => {
 
     // Deleting from the beginning
     const deletedValue = list.deleteAt(0);
-    expect(deletedValue).toBe(1);
-    expect(list.length).toBe(2);
+    expect(deletedValue).toBe(true);
+    expect(list.size).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.size).toBe(1);
     expect(list.head!.value).toBe(3);
 
     // Deleting from the end
     list.deleteAt(0);
-    expect(list.length).toBe(0);
+    expect(list.size).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -144,16 +144,16 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
 
     list.delete(2);
-    expect(list.length).toBe(2);
+    expect(list.size).toBe(2);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(3);
 
     list.delete(1);
-    expect(list.length).toBe(1);
+    expect(list.size).toBe(1);
     expect(list.head!.value).toBe(3);
 
     list.delete(3);
-    expect(list.length).toBe(0);
+    expect(list.size).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -206,7 +206,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    list.insertAfter(2, 2.5);
+    list.addAfter(2, 2.5);
 
     expect(list.toArray()).toEqual([1, 2, 2.5, 3]);
   });
@@ -216,7 +216,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    list.insertBefore(2, 1.5);
+    list.addBefore(2, 1.5);
 
     expect(list.toArray()).toEqual([1, 1.5, 2, 3]);
   });
@@ -258,7 +258,7 @@ describe('DoublyLinkedList Operation Test', () => {
 
     list.clear();
 
-    expect(list.length).toBe(0);
+    expect(list.size).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -334,7 +334,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const success = list.insertAfter(2, 4);
+    const success = list.addAfter(2, 4);
     expect(success).toBe(true);
     expect(list.toArray()).toEqual([1, 2, 4, 3]);
   });
@@ -344,7 +344,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const success = list.insertBefore(2, 0);
+    const success = list.addBefore(2, 0);
     expect(success).toBe(true);
     expect(list.toArray()).toEqual([1, 0, 2, 3]);
   });
@@ -354,7 +354,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const success = list.insertAfter(4, 5);
+    const success = list.addAfter(4, 5);
     expect(success).toBe(false);
     expect(list.toArray()).toEqual([1, 2, 3]);
   });
@@ -364,7 +364,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const success = list.insertBefore(4, 0);
+    const success = list.addBefore(4, 0);
     expect(success).toBe(false);
     expect(list.toArray()).toEqual([1, 2, 3]);
   });
@@ -381,7 +381,7 @@ describe('DoublyLinkedList Operation Test', () => {
     expect(objectList.toArray()).toEqual([obj1, obj2, obj3]);
 
     const newObj = { keyA: 25 }; // Corrected newObj value
-    const insertSuccess = objectList.insertBefore(obj2, newObj);
+    const insertSuccess = objectList.addBefore(obj2, newObj);
     expect(insertSuccess).toBe(true);
 
     const getNode = objectList.getNode(newObj); // Use newObj instead of obj2

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

@@ -2,7 +2,7 @@
 // import {bigO, magnitude} from '../../../utils';
 
 describe('LinkedList Performance Test', () => {
-  it('should DoublyLinkedList insertBefore faster than SinglyLinkedList', () => {
+  it('should DoublyLinkedList addBefore faster than SinglyLinkedList', () => {
     expect(1).toBe(1);
   });
 });