data-structure-typed 1.49.0 → 1.49.2

package/dist/mjs/data-structures/stack/stack.js

@@ -1,8 +1,11 @@
-import { IterableElementBase } from "../base";
+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 extends IterableElementBase {
     /**
@@ -84,7 +87,7 @@ export class Stack extends IterableElementBase {
      */
     push(element) {
         this.elements.push(element);
-        return this;
+        return true;
     }
     /**
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
@@ -100,8 +103,8 @@ export class Stack extends IterableElementBase {
      */
     pop() {
         if (this.isEmpty())
-            return undefined;
-        return this.elements.pop() || undefined;
+            return;
+        return this.elements.pop();
     }
     /**
      * Time Complexity: O(n)
@@ -194,9 +197,6 @@ export class Stack extends IterableElementBase {
         }
         return newStack;
     }
-    print() {
-        console.log([...this]);
-    }
     /**
      * Custom iterator for the Stack class.
      * @returns An iterator object.

package/dist/mjs/data-structures/trie/trie.d.ts

@@ -5,8 +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,
  * and a flag indicating whether it's the end of a word.
@@ -18,7 +18,17 @@ export declare class TrieNode {
     constructor(key: string);
 }
 /**
- * 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 declare class Trie extends IterableElementBase<string> {
     constructor(words?: string[], caseSensitive?: boolean);
@@ -162,7 +172,7 @@ export declare 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[];
+    filter(predicate: ElementCallback<string, boolean>, thisArg?: any): Trie;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -181,7 +191,6 @@ export declare class Trie extends IterableElementBase<string> {
      * @returns The `map` function is returning a new Trie object.
      */
     map(callback: ElementCallback<string, string>, thisArg?: any): Trie;
-    print(): void;
     protected _getIterator(): IterableIterator<string>;
     /**
      * Time Complexity: O(M), where M is the length of the input string.

package/dist/mjs/data-structures/trie/trie.js

@@ -1,11 +1,4 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import { IterableElementBase } from "../base";
+import { IterableElementBase } from '../base';
 /**
  * TrieNode represents a node in the Trie data structure. It holds a character key, a map of children nodes,
  * and a flag indicating whether it's the end of a word.
@@ -21,7 +14,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 {
     constructor(words, caseSensitive = true) {
@@ -340,11 +343,11 @@ export class Trie extends IterableElementBase {
      * @returns The `filter` method is returning an array of strings (`string[]`).
      */
     filter(predicate, thisArg) {
-        const results = [];
+        const results = new Trie();
         let index = 0;
         for (const word of this) {
             if (predicate.call(thisArg, word, index, this)) {
-                results.push(word);
+                results.add(word);
             }
             index++;
         }
@@ -376,9 +379,6 @@ export class Trie extends IterableElementBase {
         }
         return newTrie;
     }
-    print() {
-        console.log([...this]);
-    }
     *_getIterator() {
         function* _dfs(node, path) {
             if (node.isEnd) {

package/dist/mjs/interfaces/binary-tree.d.ts

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

package/dist/mjs/types/common.d.ts

@@ -1,15 +1,35 @@
-export type Comparator<K> = (a: K, b: K) => number;
 export declare enum BSTVariant {
     MIN = "MIN",
     MAX = "MAX"
 }
-export type DFSOrderPattern = 'pre' | 'in' | 'post';
-export type BTNCallback<N, D = any> = (node: N) => D;
 export declare 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 declare enum IterationType {
+    ITERATIVE = "ITERATIVE",
+    RECURSIVE = "RECURSIVE"
+}
+export declare 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);
 }
@@ -22,9 +42,13 @@ export type BinaryTreePrintOptions = {
     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 BTNodeExemplar<K, V, N> = BTNodeEntry<K, V> | BTNodeKeyOrNode<K, N>;
-export type BTNodePureExemplar<K, V, N> = [K, V | undefined] | BTNodePureKeyOrNode<K, N>;
+export type BTNEntry<K, V> = [K | null | undefined, V | undefined];
+export type BTNKeyOrNode<K, N> = K | null | undefined | 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/dist/mjs/types/common.js

@@ -9,3 +9,24 @@ export var CP;
     CP["eq"] = "eq";
     CP["gt"] = "gt";
 })(CP || (CP = {}));
+/**
+ * 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 var IterationType;
+(function (IterationType) {
+    IterationType["ITERATIVE"] = "ITERATIVE";
+    IterationType["RECURSIVE"] = "RECURSIVE";
+})(IterationType || (IterationType = {}));
+export var FamilyPosition;
+(function (FamilyPosition) {
+    FamilyPosition["ROOT"] = "ROOT";
+    FamilyPosition["LEFT"] = "LEFT";
+    FamilyPosition["RIGHT"] = "RIGHT";
+    FamilyPosition["ROOT_LEFT"] = "ROOT_LEFT";
+    FamilyPosition["ROOT_RIGHT"] = "ROOT_RIGHT";
+    FamilyPosition["ISOLATED"] = "ISOLATED";
+    FamilyPosition["MAL_NODE"] = "MAL_NODE";
+})(FamilyPosition || (FamilyPosition = {}));

package/dist/mjs/types/data-structures/binary-tree/binary-tree.d.ts

@@ -1,31 +1,8 @@
 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 declare enum IterationType {
-    ITERATIVE = "ITERATIVE",
-    RECURSIVE = "RECURSIVE"
-}
-export declare 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>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BinaryTreeNested<K, V, N extends BinaryTreeNode<K, V, N>> = BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BinaryTreeOptions<K> = {
     iterationType: IterationType;
     extractor: (key: K) => number;
 };
-export type NodeDisplayLayout = [string[], number, number, number];

package/dist/mjs/types/data-structures/binary-tree/binary-tree.js

@@ -1,21 +1 @@
-/**
- * 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 var IterationType;
-(function (IterationType) {
-    IterationType["ITERATIVE"] = "ITERATIVE";
-    IterationType["RECURSIVE"] = "RECURSIVE";
-})(IterationType || (IterationType = {}));
-export var FamilyPosition;
-(function (FamilyPosition) {
-    FamilyPosition["ROOT"] = "ROOT";
-    FamilyPosition["LEFT"] = "LEFT";
-    FamilyPosition["RIGHT"] = "RIGHT";
-    FamilyPosition["ROOT_LEFT"] = "ROOT_LEFT";
-    FamilyPosition["ROOT_RIGHT"] = "ROOT_RIGHT";
-    FamilyPosition["ISOLATED"] = "ISOLATED";
-    FamilyPosition["MAL_NODE"] = "MAL_NODE";
-})(FamilyPosition || (FamilyPosition = {}));
+export {};

package/dist/mjs/types/data-structures/binary-tree/rb-tree.d.ts

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

package/dist/mjs/types/data-structures/binary-tree/tree-multimap.d.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>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type TreeMultimapNested<K, V, N extends TreeMultimapNode<K, V, N>> = TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type TreeMultimapOptions<K> = Omit<AVLTreeOptions<K>, 'isMergeDuplicatedNodeByKey'> & {};