data-structure-typed 1.49.0 → 1.49.2

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

@@ -1,10 +1,20 @@
-import { IterableElementBase } from "../base";
-import { ElementCallback } from "../../types";
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type { ElementCallback } from '../../types';
+import { IterableElementBase } from '../base';
 
 /**
- * @license MIT
- * @copyright Tyler Zeng <zrwusa@gmail.com>
- * @class
+ * 1. Last In, First Out (LIFO): The core characteristic of a stack is its last in, first out nature, meaning the last element added to the stack will be the first to be removed.
+ * 2. Uses: Stacks are commonly used for managing a series of tasks or elements that need to be processed in a last in, first out manner. They are widely used in various scenarios, such as in function calls in programming languages, evaluation of arithmetic expressions, and backtracking algorithms.
+ * 3. Performance: Stack operations are typically O(1) in time complexity, meaning that regardless of the stack's size, adding, removing, and viewing the top element are very fast operations.
+ * 4. Function Calls: In most modern programming languages, the records of function calls are managed through a stack. When a function is called, its record (including parameters, local variables, and return address) is 'pushed' into the stack. When the function returns, its record is 'popped' from the stack.
+ * 5. Expression Evaluation: Used for the evaluation of arithmetic or logical expressions, especially when dealing with parenthesis matching and operator precedence.
+ * 6. Backtracking Algorithms: In problems where multiple branches need to be explored but only one branch can be explored at a time, stacks can be used to save the state at each branching point.
  */
 export class Stack<E = any> extends IterableElementBase<E> {
   /**
@@ -94,9 +104,9 @@ export class Stack<E = any> extends IterableElementBase<E> {
    * @param {E} element - The parameter "element" is of type E, which means it can be any data type.
    * @returns The `push` method is returning the updated `Stack<E>` object.
    */
-  push(element: E): Stack<E> {
+  push(element: E): boolean {
     this.elements.push(element);
-    return this;
+    return true;
   }
 
   /**
@@ -113,9 +123,9 @@ export class Stack<E = any> extends IterableElementBase<E> {
    * array is empty, it returns `undefined`.
    */
   pop(): E | undefined {
-    if (this.isEmpty()) return undefined;
+    if (this.isEmpty()) return;
 
-    return this.elements.pop() || undefined;
+    return this.elements.pop();
   }
 
   /**
@@ -218,15 +228,11 @@ export class Stack<E = any> extends IterableElementBase<E> {
     return newStack;
   }
 
-  print(): void {
-    console.log([...this]);
-  }
-
   /**
    * Custom iterator for the Stack class.
    * @returns An iterator object.
    */
-  protected* _getIterator() {
+  protected* _getIterator(): IterableIterator<E> {
     for (let i = 0; i < this.elements.length; i++) {
       yield this.elements[i];
     }

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

@@ -5,9 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-
-import { IterableElementBase } from "../base";
-import { ElementCallback } from "../../types";
+import type { ElementCallback } from '../../types';
+import { IterableElementBase } from '../base';
 
 /**
  * TrieNode represents a node in the Trie data structure. It holds a character key, a map of children nodes,
@@ -26,7 +25,17 @@ export class TrieNode {
 }
 
 /**
- * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
+ * 1. Node Structure: Each node in a Trie represents a string (or a part of a string). The root node typically represents an empty string.
+ * 2. Child Node Relationship: Each node's children represent the strings that can be formed by adding one character to the string at the current node. For example, if a node represents the string 'ca', one of its children might represent 'cat'.
+ * 3. Fast Retrieval: Trie allows retrieval in O(m) time complexity, where m is the length of the string to be searched.
+ * 4. Space Efficiency: Trie can store a large number of strings very space-efficiently, especially when these strings share common prefixes.
+ * 5. Autocomplete and Prediction: Trie can be used for implementing autocomplete and word prediction features, as it can quickly find all strings with a common prefix.
+ * 6. Sorting: Trie can be used to sort a set of strings in alphabetical order.
+ * 7. String Retrieval: For example, searching for a specific string in a large set of strings.
+ * 8. Autocomplete: Providing recommended words or phrases as a user types.
+ * 9. Spell Check: Checking the spelling of words.
+ * 10. IP Routing: Used in certain types of IP routing algorithms.
+ * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data."
  */
 export class Trie extends IterableElementBase<string> {
   constructor(words?: string[], caseSensitive = true) {
@@ -129,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 => {
@@ -175,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) {
@@ -362,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++;
     }
@@ -402,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/src/interfaces/binary-tree.ts

@@ -1,11 +1,11 @@
 import { BinaryTree, BinaryTreeNode } from '../data-structures';
 import {
+  BinaryTreeDeleteResult,
   BinaryTreeNested,
   BinaryTreeNodeNested,
   BinaryTreeOptions,
-  BiTreeDeleteResult,
   BTNCallback,
-  BTNodeExemplar,
+  BTNExemplar,
 } from '../types';
 
 export interface IBinaryTree<K = number, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNodeNested<K, V>, TREE extends BinaryTree<K, V, N, TREE> = BinaryTreeNested<K, V, N>> {
@@ -13,9 +13,9 @@ export interface IBinaryTree<K = number, V = any, N extends BinaryTreeNode<K, V,
 
   createTree(options?: Partial<BinaryTreeOptions<K>>): TREE;
 
-  add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V, count?: number): N | null | undefined;
+  add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V, count?: number): N | null | undefined;
 
-  addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[];
+  addMany(nodes: Iterable<BTNExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[];
 
-  delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BiTreeDeleteResult<N>[];
+  delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeleteResult<N>[];
 }

package/src/types/common.ts

@@ -1,20 +1,43 @@
-export type Comparator<K> = (a: K, b: K) => number;
-
 export enum BSTVariant {
   MIN = 'MIN',
   MAX = 'MAX',
 }
 
-export type DFSOrderPattern = 'pre' | 'in' | 'post';
-
-export type BTNCallback<N, D = any> = (node: N) => D;
-
 export enum CP {
   lt = 'lt',
   eq = 'eq',
   gt = 'gt'
 }
 
+/**
+ * Enum representing different loop types.
+ *
+ * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
+ * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
+ */
+export enum IterationType {
+  ITERATIVE = 'ITERATIVE',
+  RECURSIVE = 'RECURSIVE'
+}
+
+export enum FamilyPosition {
+  ROOT = 'ROOT',
+  LEFT = 'LEFT',
+  RIGHT = 'RIGHT',
+  ROOT_LEFT = 'ROOT_LEFT',
+  ROOT_RIGHT = 'ROOT_RIGHT',
+  ISOLATED = 'ISOLATED',
+  MAL_NODE = 'MAL_NODE'
+}
+
+export type Comparator<K> = (a: K, b: K) => number;
+
+export type DFSOrderPattern = 'pre' | 'in' | 'post';
+
+export type NodeDisplayLayout = [string[], number, number, number];
+
+export type BTNCallback<N, D = any> = (node: N) => D;
+
 export interface IterableWithSize<T> extends Iterable<T> {
   size: number | ((...args: any[]) => number);
 }
@@ -27,14 +50,16 @@ export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLeng
 
 export type BinaryTreePrintOptions = { isShowUndefined?: boolean, isShowNull?: boolean, isShowRedBlackNIL?: boolean }
 
-export type BTNodeEntry<K, V> = [K | null | undefined, V | undefined];
-
-export type BTNodeKeyOrNode<K, N> = K | null | undefined | N;
+export type BTNEntry<K, V> = [K | null | undefined, V | undefined];
 
-export type BTNodeExemplar<K, V, N> = BTNodeEntry<K, V> | BTNodeKeyOrNode<K, N>
+export type BTNKeyOrNode<K, N> = K | null | undefined | N;
 
-export type BTNodePureExemplar<K, V, N> = [K, V | undefined] | BTNodePureKeyOrNode<K, N>
+export type BTNExemplar<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>
 
 export type BTNodePureKeyOrNode<K, N> = K | N;
 
-export type BSTNodeKeyOrNode<K, N> = K | undefined | N;
+export type BTNodePureExemplar<K, V, N> = [K, V | undefined] | BTNodePureKeyOrNode<K, N>;
+
+export type BSTNKeyOrNode<K, N> = K | undefined | N;
+
+export type BinaryTreeDeleteResult<N> = { deleted: N | null | undefined; needBalanced: N | null | undefined };

package/src/types/data-structures/binary-tree/avl-tree.ts

@@ -5,5 +5,4 @@ export type AVLTreeNodeNested<K, V> = AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTre
 
 export type AVLTreeNested<K, V, N extends AVLTreeNode<K, V, N>> = AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-
 export type AVLTreeOptions<K> = BSTOptions<K> & {};

package/src/types/data-structures/binary-tree/binary-tree.ts

@@ -1,28 +1,5 @@
 import { BinaryTree, BinaryTreeNode } from '../../../data-structures';
-
-/**
- * Enum representing different loop types.
- *
- * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
- * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
- */
-
-export enum IterationType {
-  ITERATIVE = 'ITERATIVE',
-  RECURSIVE = 'RECURSIVE'
-}
-
-export enum FamilyPosition {
-  ROOT = 'ROOT',
-  LEFT = 'LEFT',
-  RIGHT = 'RIGHT',
-  ROOT_LEFT = 'ROOT_LEFT',
-  ROOT_RIGHT = 'ROOT_RIGHT',
-  ISOLATED = 'ISOLATED',
-  MAL_NODE = 'MAL_NODE'
-}
-
-export type BiTreeDeleteResult<N> = { deleted: N | null | undefined; needBalanced: N | null | undefined };
+import { IterationType } from "../../common";
 
 export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
@@ -32,5 +9,3 @@ export type BinaryTreeOptions<K> = {
   iterationType: IterationType,
   extractor: (key: K) => number
 }
-
-export type NodeDisplayLayout = [string[], number, number, number];

package/src/types/data-structures/binary-tree/bst.ts

@@ -2,7 +2,6 @@ import { BST, BSTNode } from '../../../data-structures';
 import type { BinaryTreeOptions } from './binary-tree';
 import { BSTVariant } from "../../common";
 
-// prettier-ignore
 export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
 export type BSTNested<K, V, N extends BSTNode<K, V, N>> = BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

package/src/types/data-structures/binary-tree/rb-tree.ts

@@ -1,5 +1,5 @@
 import { RedBlackTree, RedBlackTreeNode } from '../../../data-structures';
-import { BSTOptions } from "./bst";
+import type { BSTOptions } from "./bst";
 
 export enum RBTNColor { RED = 1, BLACK = 0}
 

package/src/types/data-structures/binary-tree/tree-multimap.ts

@@ -1,5 +1,5 @@
 import { TreeMultimap, TreeMultimapNode } from '../../../data-structures';
-import { AVLTreeOptions } from './avl-tree';
+import type { AVLTreeOptions } from './avl-tree';
 
 export type TreeMultimapNodeNested<K, V> = TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 

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/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(1);
+  expect(cycles.size).toBe(2);
   expect(scCs.size).toBe(5);
   expect(bridges.length).toBe(4);
   expect(cutVertexes.length).toBe(4);
@@ -673,3 +673,23 @@ describe('DirectedGraph iterative Methods', () => {
   })
 });
 
+describe('DirectedGraph getCycles', () => {
+  test('should getCycles return correct result', () => {
+    const graph = new DirectedGraph();
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+    graph.addVertex('E');
+    graph.addEdge('A', 'B');
+    graph.addEdge('A', 'C');
+    graph.addEdge('B', 'D');
+    graph.addEdge('C', 'D');
+    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 }]);
+  })
+})
+

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

@@ -237,10 +237,48 @@ 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(1);
+  expect(cycles.size).toBe(2);
   expect(scCs.size).toBe(5);
   expect(bridges.length).toBe(4);
   expect(cutVertexes.length).toBe(4);
   expect(dfnMap.size).toBe(8);
   expect(lowMap.size).toBe(8);
 });
+
+it("Should return Infinity if dest is not found", () => {
+
+  const graph = new UndirectedGraph<string>();
+
+  for (let i = 0; i < 3; ++i) {
+    graph.addVertex(graph.createVertex(i, `${i}`));
+  }
+
+  graph.addEdge(0, 1, 1);
+
+  const minCost02 = graph.getMinCostBetween(0, 2, true);
+  expect(minCost02).toBe(Infinity);
+
+  const minCost01 = graph.getMinCostBetween(0, 1, true);
+  expect(minCost01).toBe(1);
+});
+
+describe('UndirectedGraph getCycles', () => {
+  test('should getCycles return correct result', () => {
+    const graph = new UndirectedGraph();
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+    graph.addVertex('E');
+    graph.addEdge('A', 'B');
+    graph.addEdge('A', 'C');
+    graph.addEdge('B', 'D');
+    graph.addEdge('C', 'D');
+    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" }]);
+  })
+})

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,7 @@ 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)