min-heap-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>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>