min-heap-typed 2.1.1 → 2.1.2

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

@@ -1,4 +1,350 @@
-import { IterableElementBaseOptions } from '../base';
-export type TrieOptions<R> = {
-    caseSensitive?: boolean;
-} & IterableElementBaseOptions<string, R>;
+/**
+ * data-structure-typed
+ *
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type { ElementCallback, TrieOptions } from '../../types';
+import { IterableElementBase } from '../base';
+/**
+ * Node used by Trie to store one character and its children.
+ * @remarks Time O(1), Space O(1)
+ */
+export declare class TrieNode {
+    /**
+     * Create a Trie node with a character key.
+     * @remarks Time O(1), Space O(1)
+     * @returns New TrieNode instance.
+     */
+    constructor(key: string);
+    protected _key: string;
+    /**
+     * Get the character key of this node.
+     * @remarks Time O(1), Space O(1)
+     * @returns Character key string.
+     */
+    get key(): string;
+    /**
+     * Set the character key of this node.
+     * @remarks Time O(1), Space O(1)
+     * @param value - New character key.
+     * @returns void
+     */
+    set key(value: string);
+    protected _children: Map<string, TrieNode>;
+    /**
+     * Get the child map of this node.
+     * @remarks Time O(1), Space O(1)
+     * @returns Map from character to child node.
+     */
+    get children(): Map<string, TrieNode>;
+    /**
+     * Replace the child map of this node.
+     * @remarks Time O(1), Space O(1)
+     * @param value - New map of character → node.
+     * @returns void
+     */
+    set children(value: Map<string, TrieNode>);
+    protected _isEnd: boolean;
+    /**
+     * Check whether this node marks the end of a word.
+     * @remarks Time O(1), Space O(1)
+     * @returns True if this node ends a word.
+     */
+    get isEnd(): boolean;
+    /**
+     * Mark this node as the end of a word or not.
+     * @remarks Time O(1), Space O(1)
+     * @param value - Whether this node ends a word.
+     * @returns void
+     */
+    set isEnd(value: boolean);
+}
+/**
+ * Prefix tree (Trie) for fast prefix queries and word storage.
+ * @remarks Time O(1), Space O(1)
+ * @template R
+ * 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.
+ * @example
+ * // Autocomplete: Prefix validation and checking
+ *     const autocomplete = new Trie<string>(['gmail.com', 'gmail.co.nz', 'gmail.co.jp', 'yahoo.com', 'outlook.com']);
+ *
+ *     // Get all completions for a prefix
+ *     const gmailCompletions = autocomplete.getWords('gmail');
+ *     console.log(gmailCompletions); // ['gmail.com', 'gmail.co.nz', 'gmail.co.jp']
+ * @example
+ * // File System Path Operations
+ *     const fileSystem = new Trie<string>([
+ *       '/home/user/documents/file1.txt',
+ *       '/home/user/documents/file2.txt',
+ *       '/home/user/pictures/photo.jpg',
+ *       '/home/user/pictures/vacation/',
+ *       '/home/user/downloads'
+ *     ]);
+ *
+ *     // Find common directory prefix
+ *     console.log(fileSystem.getLongestCommonPrefix()); // '/home/user/'
+ *
+ *     // List all files in a directory
+ *     const documentsFiles = fileSystem.getWords('/home/user/documents/');
+ *     console.log(documentsFiles); // ['/home/user/documents/file1.txt', '/home/user/documents/file2.txt']
+ * @example
+ * // Autocomplete: Basic word suggestions
+ *     // Create a trie for autocomplete
+ *     const autocomplete = new Trie<string>([
+ *       'function',
+ *       'functional',
+ *       'functions',
+ *       'class',
+ *       'classes',
+ *       'classical',
+ *       'closure',
+ *       'const',
+ *       'constructor'
+ *     ]);
+ *
+ *     // Test autocomplete with different prefixes
+ *     console.log(autocomplete.getWords('fun')); // ['functional', 'functions', 'function']
+ *     console.log(autocomplete.getWords('cla')); // ['classes', 'classical', 'class']
+ *     console.log(autocomplete.getWords('con')); // ['constructor', 'const']
+ *
+ *     // Test with non-matching prefix
+ *     console.log(autocomplete.getWords('xyz')); // []
+ * @example
+ * // Dictionary: Case-insensitive word lookup
+ *     // Create a case-insensitive dictionary
+ *     const dictionary = new Trie<string>([], { caseSensitive: false });
+ *
+ *     // Add words with mixed casing
+ *     dictionary.add('Hello');
+ *     dictionary.add('WORLD');
+ *     dictionary.add('JavaScript');
+ *
+ *     // Test lookups with different casings
+ *     console.log(dictionary.has('hello')); // true
+ *     console.log(dictionary.has('HELLO')); // true
+ *     console.log(dictionary.has('Hello')); // true
+ *     console.log(dictionary.has('javascript')); // true
+ *     console.log(dictionary.has('JAVASCRIPT')); // true
+ * @example
+ * // IP Address Routing Table
+ *     // Add IP address prefixes and their corresponding routes
+ *     const routes = {
+ *       '192.168.1': 'LAN_SUBNET_1',
+ *       '192.168.2': 'LAN_SUBNET_2',
+ *       '10.0.0': 'PRIVATE_NETWORK_1',
+ *       '10.0.1': 'PRIVATE_NETWORK_2'
+ *     };
+ *
+ *     const ipRoutingTable = new Trie<string>(Object.keys(routes));
+ *
+ *     // Check IP address prefix matching
+ *     console.log(ipRoutingTable.hasPrefix('192.168.1')); // true
+ *     console.log(ipRoutingTable.hasPrefix('192.168.2')); // true
+ *
+ *     // Validate IP address belongs to subnet
+ *     const ip = '192.168.1.100';
+ *     const subnet = ip.split('.').slice(0, 3).join('.');
+ *     console.log(ipRoutingTable.hasPrefix(subnet)); // true
+ */
+export declare class Trie<R = any> extends IterableElementBase<string, R> {
+    /**
+     * Create a Trie and optionally bulk-insert words.
+     * @remarks Time O(totalChars), Space O(totalChars)
+     * @param [words] - Iterable of strings (or raw records if toElementFn is provided).
+     * @param [options] - Options such as toElementFn and caseSensitive.
+     * @returns New Trie instance.
+     */
+    constructor(words?: Iterable<string> | Iterable<R>, options?: TrieOptions<R>);
+    protected _size: number;
+    /**
+     * Get the number of stored words.
+     * @remarks Time O(1), Space O(1)
+     * @returns Word count.
+     */
+    get size(): number;
+    protected _caseSensitive: boolean;
+    /**
+     * Get whether comparisons are case-sensitive.
+     * @remarks Time O(1), Space O(1)
+     * @returns True if case-sensitive.
+     */
+    get caseSensitive(): boolean;
+    protected _root: TrieNode;
+    /**
+     * Get the root node.
+     * @remarks Time O(1), Space O(1)
+     * @returns Root TrieNode.
+     */
+    get root(): TrieNode;
+    /**
+     * (Protected) Get total count for base class iteration.
+     * @remarks Time O(1), Space O(1)
+     * @returns Total number of elements.
+     */
+    protected get _total(): number;
+    /**
+     * Insert one word into the trie.
+     * @remarks Time O(L), Space O(L)
+     * @param word - Word to insert.
+     * @returns True if the word was newly added.
+     */
+    add(word: string): boolean;
+    /**
+     * Insert many words from an iterable.
+     * @remarks Time O(ΣL), Space O(ΣL)
+     * @param words - Iterable of strings (or raw records if toElementFn is provided).
+     * @returns Array of per-word 'added' flags.
+     */
+    addMany(words: Iterable<string> | Iterable<R>): boolean[];
+    /**
+     * Check whether a word exists.
+     * @remarks Time O(L), Space O(1)
+     * @param word - Word to search for.
+     * @returns True if present.
+     */
+    has(word: string): boolean;
+    /**
+     * Check whether the trie is empty.
+     * @remarks Time O(1), Space O(1)
+     * @returns True if size is 0.
+     */
+    isEmpty(): boolean;
+    /**
+     * Remove all words and reset to a fresh root.
+     * @remarks Time O(1), Space O(1)
+     * @returns void
+     */
+    clear(): void;
+    /**
+     * Delete one word if present.
+     * @remarks Time O(L), Space O(1)
+     * @param word - Word to delete.
+     * @returns True if a word was removed.
+     */
+    delete(word: string): boolean;
+    /**
+     * Compute the height (max depth) of the trie.
+     * @remarks Time O(N), Space O(H)
+     * @returns Maximum depth from root to a leaf.
+     */
+    getHeight(): number;
+    /**
+     * Check whether input is a proper prefix of at least one word.
+     * @remarks Time O(L), Space O(1)
+     * @param input - String to test as prefix.
+     * @returns True if input is a prefix but not a full word.
+     */
+    hasPurePrefix(input: string): boolean;
+    /**
+     * Check whether any word starts with input.
+     * @remarks Time O(L), Space O(1)
+     * @param input - String to test as prefix.
+     * @returns True if input matches a path from root.
+     */
+    hasPrefix(input: string): boolean;
+    /**
+     * Check whether the trie’s longest common prefix equals input.
+     * @remarks Time O(min(H,L)), Space O(1)
+     * @param input - Candidate longest common prefix.
+     * @returns True if input equals the common prefix.
+     */
+    hasCommonPrefix(input: string): boolean;
+    /**
+     * Return the longest common prefix among all words.
+     * @remarks Time O(H), Space O(1)
+     * @returns The longest common prefix string.
+     */
+    getLongestCommonPrefix(): string;
+    /**
+     * Collect words under a prefix up to a maximum count.
+     * @remarks Time O(K·L), Space O(K·L)
+     * @param [prefix] - Prefix to match; default empty string for root.
+     * @param [max] - Maximum number of words to return; default is Number.MAX_SAFE_INTEGER.
+     * @param [isAllWhenEmptyPrefix] - When true, collect from root even if prefix is empty.
+     * @returns Array of collected words (at most max).
+     */
+    getWords(prefix?: string, max?: number, isAllWhenEmptyPrefix?: boolean): string[];
+    /**
+     * Deep clone this trie by iterating and inserting all words.
+     * @remarks Time O(ΣL), Space O(ΣL)
+     * @returns A new trie with the same words and options.
+     */
+    clone(): this;
+    /**
+     * Filter words into a new trie of the same class.
+     * @remarks Time O(ΣL), Space O(ΣL)
+     * @param predicate - Predicate (word, index, trie) → boolean to keep word.
+     * @param [thisArg] - Value for `this` inside the predicate.
+     * @returns A new trie containing words that satisfy the predicate.
+     */
+    filter(predicate: ElementCallback<string, R, boolean>, thisArg?: any): this;
+    map<RM>(callback: ElementCallback<string, R, string>, options?: TrieOptions<RM>, thisArg?: any): Trie<RM>;
+    /**
+     * Map words into a new trie (possibly different record type).
+     * @remarks Time O(ΣL), Space O(ΣL)
+     * @template EM
+     * @template RM
+     * @param callback - Mapping function (word, index, trie) → newWord (string).
+     * @param [options] - Options for the output trie (e.g., toElementFn, caseSensitive).
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new Trie constructed from mapped words.
+     */
+    map<EM, RM>(callback: ElementCallback<string, R, EM>, options?: TrieOptions<RM>, thisArg?: any): IterableElementBase<EM, RM>;
+    /**
+     * Map words into a new trie of the same element type.
+     * @remarks Time O(ΣL), Space O(ΣL)
+     * @param callback - Mapping function (word, index, trie) → string.
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new trie with mapped words.
+     */
+    mapSame(callback: ElementCallback<string, R, string>, thisArg?: any): this;
+    /**
+     * (Protected) Create an empty instance of the same concrete class.
+     * @remarks Time O(1), Space O(1)
+     * @param [options] - Options forwarded to the constructor.
+     * @returns An empty like-kind trie instance.
+     */
+    protected _createInstance(options?: TrieOptions<R>): this;
+    /**
+     * (Protected) Create a like-kind trie and seed it from an iterable.
+     * @remarks Time O(ΣL), Space O(ΣL)
+     * @template RM
+     * @param [elements] - Iterable used to seed the new trie.
+     * @param [options] - Options forwarded to the constructor.
+     * @returns A like-kind Trie instance.
+     */
+    protected _createLike<RM>(elements?: Iterable<string> | Iterable<RM>, options?: TrieOptions<RM>): Trie<RM>;
+    /**
+     * (Protected) Spawn an empty like-kind trie instance.
+     * @remarks Time O(1), Space O(1)
+     * @template RM
+     * @param [options] - Options forwarded to the constructor.
+     * @returns An empty like-kind Trie instance.
+     */
+    protected _spawnLike<RM>(options?: TrieOptions<RM>): Trie<RM>;
+    /**
+     * (Protected) Iterate all words in lexicographic order of edges.
+     * @remarks Time O(ΣL), Space O(H)
+     * @returns Iterator of words.
+     */
+    protected _getIterator(): IterableIterator<string>;
+    /**
+     * (Protected) Normalize a string according to case sensitivity.
+     * @remarks Time O(L), Space O(L)
+     * @param str - Input string to normalize.
+     * @returns Normalized string based on caseSensitive.
+     */
+    protected _caseProcess(str: string): string;
+}

package/dist/types/index.d.ts

@@ -1,3 +1,14 @@
-export * from './data-structures';
+/**
+ * data-structure-typed
+ *
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export * from './data-structures/heap/min-heap';
+export * from './data-structures/heap/heap';
+export * from './types/data-structures/heap/min-heap';
+export * from './types/data-structures/heap/heap';
+export * from './types/common';
+export * from './types/utils';
 export * from './common';
-export * from './utils';

package/dist/{interfaces → types/interfaces}/binary-tree.d.ts

@@ -14,7 +14,7 @@ export interface IBinaryTree<K = any, V = any, R = any> {
     readonly store: Map<K, V | undefined>;
     readonly toEntryFn?: ToEntryFn<K, V, R>;
     readonly isDuplicate: boolean;
-    _createNode(key: K, value?: BinaryTreeNode<K, V>['value']): BinaryTreeNode<K, V>;
+    createNode(key: K, value?: BinaryTreeNode<K, V>['value']): BinaryTreeNode<K, V>;
     createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): IBinaryTree<K, V, R>;
     add(keyOrNodeOrEntryOrRawElement: BTNRep<K, V, BinaryTreeNode<K, V>>, value?: V, count?: number): boolean;
     addMany(keysNodesEntriesOrRaws: Iterable<K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, values?: Iterable<V | undefined>): boolean[];

package/dist/types/types/data-structures/base/index.d.ts

@@ -0,0 +1 @@
+export * from './base';

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

@@ -0,0 +1,2 @@
+import { AVLTreeOptions } from './avl-tree';
+export type AVLTreeCounterOptions<K, V, R> = AVLTreeOptions<K, V, R> & {};

package/dist/types/types/data-structures/binary-tree/avl-tree-multi-map.d.ts

@@ -0,0 +1,2 @@
+import type { AVLTreeOptions } from './avl-tree';
+export type AVLTreeMultiMapOptions<K, V, R> = AVLTreeOptions<K, V, R> & {};

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

@@ -0,0 +1,2 @@
+import { BSTOptions } from './bst';
+export type AVLTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,29 @@
+import { IterationType, OptValue } from '../../common';
+import { DFSOperation } from '../../../common';
+export type ToEntryFn<K, V, R> = (rawElement: R) => BTNEntry<K, V>;
+export type BinaryTreeOptions<K, V, R> = {
+    iterationType?: IterationType;
+    toEntryFn?: ToEntryFn<K, V, R>;
+    isMapMode?: boolean;
+    isDuplicate?: boolean;
+};
+export type BinaryTreePrintOptions = {
+    isShowUndefined?: boolean;
+    isShowNull?: boolean;
+    isShowRedBlackNIL?: boolean;
+};
+export type OptNodeOrNull<NODE> = NODE | null | undefined;
+export type BTNOptKeyOrNull<K> = K | null | undefined;
+export type BTNEntry<K, V> = [BTNOptKeyOrNull<K>, OptValue<V>];
+export type BTNOptKeyNodeOrNull<K, NODE> = BTNOptKeyOrNull<K> | NODE;
+export type BTNRep<K, V, NODE> = BTNEntry<K, V> | BTNOptKeyNodeOrNull<K, NODE>;
+export type BinaryTreeDeleteResult<NODE> = {
+    deleted: OptNodeOrNull<NODE>;
+    needBalanced: OptNodeOrNull<NODE>;
+};
+export type NodeCallback<NODE, D = any> = (node: NODE) => D;
+export type NodePredicate<NODE> = (node: NODE) => boolean;
+export type DFSStackItem<NODE> = {
+    opt: DFSOperation;
+    node: OptNodeOrNull<NODE>;
+};

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

@@ -0,0 +1,12 @@
+import type { BinaryTreeOptions } from './binary-tree';
+import { Comparable } from '../../utils';
+import { OptValue } from '../../common';
+export type BSTOptions<K, V, R> = Omit<BinaryTreeOptions<K, V, R>, 'isDuplicate'> & {
+    specifyComparable?: (key: K) => Comparable;
+    isReverse?: boolean;
+};
+export type BSTNOptKey<K> = K | undefined;
+export type OptNode<NODE> = NODE | undefined;
+export type BSTNEntry<K, V> = [BSTNOptKey<K>, OptValue<V>];
+export type BSTNOptKeyOrNode<K, NODE> = BSTNOptKey<K> | NODE;
+export type BSTNRep<K, V, NODE> = BSTNEntry<K, V> | BSTNOptKeyOrNode<K, NODE>;

package/dist/{data-structures → types/types/data-structures}/binary-tree/index.d.ts

@@ -1,10 +1,9 @@
 export * from './binary-tree';
 export * from './bst';
-export * from './binary-indexed-tree';
-export * from './segment-tree';
 export * from './avl-tree';
-export * from './red-black-tree';
+export * from './segment-tree';
 export * from './avl-tree-multi-map';
+export * from './red-black-tree';
 export * from './tree-multi-map';
 export * from './tree-counter';
 export * from './avl-tree-counter';

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

@@ -0,0 +1,3 @@
+import type { BSTOptions } from './bst';
+export type RBTNColor = 'RED' | 'BLACK';
+export type RedBlackTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};

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

@@ -0,0 +1 @@
+export type SegmentTreeNodeVal = number;

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

@@ -0,0 +1,2 @@
+import type { RedBlackTreeOptions } from './red-black-tree';
+export type TreeCounterOptions<K, V, R> = RedBlackTreeOptions<K, V, R> & {};

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

@@ -0,0 +1,2 @@
+import type { RedBlackTreeOptions } from './red-black-tree';
+export type TreeMultiMapOptions<K, V, R> = RedBlackTreeOptions<K, V, R> & {};

package/dist/types/types/data-structures/graph/abstract-graph.d.ts

@@ -0,0 +1,14 @@
+export type VertexKey = string | number;
+export type DijkstraResult<V> = {
+    distMap: Map<V, number>;
+    distPaths?: Map<V, V[]>;
+    preMap: Map<V, V | undefined>;
+    seen: Set<V>;
+    paths: V[][];
+    minDist: number;
+    minPath: V[];
+} | undefined;
+export type GraphOptions<V = any> = {
+    vertexValueInitializer?: (key: VertexKey) => V;
+    defaultEdgeWeight?: number;
+};

package/dist/types/types/data-structures/graph/directed-graph.d.ts

@@ -0,0 +1 @@
+export type TopologicalStatus = 0 | 1 | 2;

package/dist/{data-structures → types/types/data-structures}/graph/index.d.ts

@@ -1,4 +1,3 @@
 export * from './abstract-graph';
-export * from './directed-graph';
-export * from './undirected-graph';
 export * from './map-graph';
+export * from './directed-graph';

package/dist/types/types/data-structures/graph/map-graph.d.ts

@@ -0,0 +1 @@
+export type MapGraphCoordinate = [number, number];

package/dist/types/types/data-structures/graph/undirected-graph.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/types/data-structures/hash/hash-map.d.ts

@@ -0,0 +1,19 @@
+export type HashMapLinkedNode<K, V> = {
+    key: K;
+    value: V;
+    next: HashMapLinkedNode<K, V>;
+    prev: HashMapLinkedNode<K, V>;
+};
+export type LinkedHashMapOptions<K, V, R> = {
+    hashFn?: (key: K) => string;
+    objHashFn?: (key: K) => object;
+    toEntryFn?: (rawElement: R) => [K, V];
+};
+export type HashMapOptions<K, V, R> = {
+    hashFn?: (key: K) => string;
+    toEntryFn?: (rawElement: R) => [K, V];
+};
+export type HashMapStoreItem<K, V> = {
+    key: K;
+    value: V;
+};

package/dist/types/types/data-structures/hash/index.d.ts

@@ -0,0 +1,2 @@
+export * from './hash-map';
+export type HashFunction<K> = (key: K) => number;

package/dist/types/types/data-structures/heap/heap.d.ts

@@ -0,0 +1,5 @@
+import { Comparator } from '../../common';
+import { IterableElementBaseOptions } from '../base';
+export type HeapOptions<E, R> = IterableElementBaseOptions<E, R> & {
+    comparator?: Comparator<E>;
+};

package/dist/types/types/data-structures/heap/index.d.ts

@@ -0,0 +1 @@
+export * from './heap';

package/dist/types/types/data-structures/heap/max-heap.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/types/data-structures/heap/min-heap.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/types/data-structures/linked-list/doubly-linked-list.d.ts

@@ -0,0 +1,2 @@
+import { LinearBaseOptions } from '../base';
+export type DoublyLinkedListOptions<E, R> = LinearBaseOptions<E, R> & {};

package/dist/types/types/data-structures/linked-list/singly-linked-list.d.ts

@@ -0,0 +1,2 @@
+import { LinearBaseOptions } from '../base';
+export type SinglyLinkedListOptions<E, R> = LinearBaseOptions<E, R> & {};

package/dist/types/types/data-structures/linked-list/skip-linked-list.d.ts

@@ -0,0 +1,4 @@
+export type SkipLinkedListOptions = {
+    maxLevel?: number;
+    probability?: number;
+};

package/dist/types/types/data-structures/matrix/matrix.d.ts

@@ -0,0 +1,7 @@
+export type MatrixOptions = {
+    rows?: number;
+    cols?: number;
+    addFn?: (a: number, b: number) => any;
+    subtractFn?: (a: number, b: number) => any;
+    multiplyFn?: (a: number, b: number) => any;
+};

package/dist/types/types/data-structures/matrix/navigator.d.ts

@@ -0,0 +1,14 @@
+export type Direction = 'up' | 'right' | 'down' | 'left';
+export type Turning = {
+    [key in Direction]: Direction;
+};
+export type NavigatorParams<T = any> = {
+    matrix: T[][];
+    turning: Turning;
+    onMove: (cur: [number, number]) => void;
+    init: {
+        cur: [number, number];
+        charDir: Direction;
+        VISITED: T;
+    };
+};

package/dist/types/types/data-structures/priority-queue/max-priority-queue.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/types/data-structures/priority-queue/min-priority-queue.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/types/data-structures/priority-queue/priority-queue.d.ts

@@ -0,0 +1,2 @@
+import { HeapOptions } from '../heap';
+export type PriorityQueueOptions<E, R> = HeapOptions<E, R> & {};

package/dist/types/types/data-structures/queue/deque.d.ts

@@ -0,0 +1,4 @@
+import { LinearBaseOptions } from '../base';
+export type DequeOptions<E, R> = {
+    bucketSize?: number;
+} & LinearBaseOptions<E, R>;

package/dist/types/types/data-structures/queue/queue.d.ts

@@ -0,0 +1,4 @@
+import { LinearBaseOptions } from '../base';
+export type QueueOptions<E, R> = LinearBaseOptions<E, R> & {
+    autoCompactRatio?: number;
+};

package/dist/types/types/data-structures/stack/stack.d.ts

@@ -0,0 +1,2 @@
+import { IterableElementBaseOptions } from '../base';
+export type StackOptions<E, R> = IterableElementBaseOptions<E, R> & {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+import { IterableElementBaseOptions } from '../base';
+export type TrieOptions<R> = {
+    caseSensitive?: boolean;
+} & IterableElementBaseOptions<string, R>;

package/dist/types/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './data-structures';
+export * from './common';
+export * from './utils';

package/dist/types/types/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './utils';
+export * from './validate-type';