min-heap-typed 1.38.0 → 1.38.1

package/dist/data-structures/queue/queue.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = exports.LinkedListQueue = void 0;
+/**
+ * @license MIT
+ * @copyright Tyler Zeng <zrwusa@gmail.com>
+ * @class
+ */
+const linked_list_1 = require("../linked-list");
+class LinkedListQueue extends linked_list_1.SinglyLinkedList {
+    /**
+     * The enqueue function adds a value to the end of an array.
+     * @param {E} value - The value parameter represents the value that you want to add to the queue.
+     */
+    enqueue(value) {
+        this.push(value);
+    }
+    /**
+     * The `dequeue` function removes and returns the first element from a queue, or returns null if the queue is empty.
+     * @returns The method is returning the element at the front of the queue, or null if the queue is empty.
+     */
+    dequeue() {
+        return this.shift();
+    }
+    /**
+     * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+     */
+    peek() {
+        var _a;
+        return (_a = this.head) === null || _a === void 0 ? void 0 : _a.val;
+    }
+}
+exports.LinkedListQueue = LinkedListQueue;
+class Queue {
+    /**
+     * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
+     * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
+     * will be used to initialize the `_nodes` property of the class. If not provided, the `_nodes` property will be
+     * initialized as an empty array.
+     */
+    constructor(elements) {
+        this._nodes = elements || [];
+        this._offset = 0;
+    }
+    get nodes() {
+        return this._nodes;
+    }
+    set nodes(value) {
+        this._nodes = value;
+    }
+    get offset() {
+        return this._offset;
+    }
+    set offset(value) {
+        this._offset = value;
+    }
+    /**
+     * The size function returns the number of elements in an array.
+     * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
+     */
+    get size() {
+        return this.nodes.length - this.offset;
+    }
+    /**
+     * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
+     * @public
+     * @static
+     * @param {E[]} elements - The "elements" parameter is an array of elements of type E.
+     * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
+     * array.
+     */
+    static fromArray(elements) {
+        return new Queue(elements);
+    }
+    /**
+     * The push function adds an element to the end of the queue and returns the updated queue.Adds an element at the back of the queue.
+     * @param {E} element - The `element` parameter represents the element that you want to add to the queue.
+     * @returns The `add` method is returning a `Queue<E>` object.
+     */
+    push(element) {
+        this.nodes.push(element);
+        return this;
+    }
+    /**
+     * The `shift` function removes and returns the first element in the queue, and adjusts the internal data structure if
+     * necessary to optimize performance.
+     * @returns The function `shift()` returns either the first element in the queue or `null` if the queue is empty.
+     */
+    shift() {
+        if (this.size === 0)
+            return undefined;
+        const first = this.peek();
+        this.offset += 1;
+        if (this.offset * 2 < this.nodes.length)
+            return first;
+        // only delete dequeued elements when reaching half size
+        // to decrease latency of shifting elements.
+        this.nodes = this.nodes.slice(this.offset);
+        this.offset = 0;
+        return first;
+    }
+    /**
+     * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
+     * @returns The `peek()` method returns the first element of the data structure, represented by the `_nodes` array at
+     * the `_offset` index. If the data structure is empty (size is 0), it returns `null`.
+     */
+    peek() {
+        return this.size > 0 ? this.nodes[this.offset] : undefined;
+    }
+    /**
+     * The `peekLast` function returns the last element in an array-like data structure, or null if the structure is empty.
+     * @returns The method `peekLast()` returns the last element of the `_nodes` array if the array is not empty. If the
+     * array is empty, it returns `null`.
+     */
+    peekLast() {
+        return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
+    }
+    /**
+     * The enqueue function adds a value to the end of a queue.
+     * @param {E} value - The value parameter represents the value that you want to add to the queue.
+     */
+    enqueue(value) {
+        this.push(value);
+    }
+    /**
+     * The `dequeue` function removes and returns the first element from a queue, or returns null if the queue is empty.
+     * @returns The method is returning a value of type E or null.
+     */
+    dequeue() {
+        return this.shift();
+    }
+    getAt(index) {
+        return this.nodes[index];
+    }
+    /**
+     * The function checks if a data structure is empty by comparing its size to zero.
+     * @returns {boolean} A boolean value indicating whether the size of the object is 0 or not.
+     */
+    isEmpty() {
+        return this.size === 0;
+    }
+    /**
+     * The toArray() function returns an array of elements from the current offset to the end of the _nodes array.
+     * @returns An array of type E is being returned.
+     */
+    toArray() {
+        return this.nodes.slice(this.offset);
+    }
+    /**
+     * The clear function resets the nodes array and offset to their initial values.
+     */
+    clear() {
+        this.nodes = [];
+        this.offset = 0;
+    }
+    /**
+     * The `clone()` function returns a new Queue object with the same elements as the original Queue.
+     * @returns The `clone()` method is returning a new instance of the `Queue` class.
+     */
+    clone() {
+        return new Queue(this.nodes.slice(this.offset));
+    }
+    *[Symbol.iterator]() {
+        for (const item of this.nodes) {
+            yield item;
+        }
+    }
+}
+exports.Queue = Queue;

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./stack"), exports);

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

@@ -0,0 +1,63 @@
+/**
+ * @license MIT
+ * @copyright Tyler Zeng <zrwusa@gmail.com>
+ * @class
+ */
+export declare class Stack<E = any> {
+    protected _elements: E[];
+    /**
+     * The constructor initializes an array of elements, which can be provided as an optional parameter.
+     * @param {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
+     * of elements of type `E`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
+     * is provided and is an array, it is assigned to the `_elements
+     */
+    constructor(elements?: E[]);
+    /**
+     * The function "fromArray" creates a new Stack object from an array of elements.
+     * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.
+     * @returns {Stack} The method is returning a new instance of the Stack class, initialized with the elements from the input
+     * array.
+     */
+    static fromArray<E>(elements: E[]): Stack<E>;
+    /**
+     * The function checks if an array is empty and returns a boolean value.
+     * @returns A boolean value indicating whether the `_elements` array is empty or not.
+     */
+    isEmpty(): boolean;
+    /**
+     * The size() function returns the number of elements in an array.
+     * @returns The size of the elements array.
+     */
+    size(): number;
+    /**
+     * The `peek` function returns the last element of an array, or null if the array is empty.
+     * @returns The `peek()` function returns the last element of the `_elements` array, or `null` if the array is empty.
+     */
+    peek(): E | null;
+    /**
+     * The push function adds an element to the stack and returns the updated stack.
+     * @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>;
+    /**
+     * The `pop` function removes and returns the last element from an array, or returns null if the array is empty.
+     * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
+     * array is empty, it returns `null`.
+     */
+    pop(): E | null;
+    /**
+     * The toArray function returns a copy of the elements in an array.
+     * @returns An array of type E.
+     */
+    toArray(): E[];
+    /**
+     * The clear function clears the elements array.
+     */
+    clear(): void;
+    /**
+     * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
+     * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
+     */
+    clone(): Stack<E>;
+}

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stack = void 0;
+/**
+ * @license MIT
+ * @copyright Tyler Zeng <zrwusa@gmail.com>
+ * @class
+ */
+class Stack {
+    /**
+     * The constructor initializes an array of elements, which can be provided as an optional parameter.
+     * @param {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
+     * of elements of type `E`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
+     * is provided and is an array, it is assigned to the `_elements
+     */
+    constructor(elements) {
+        this._elements = Array.isArray(elements) ? elements : [];
+    }
+    /**
+     * The function "fromArray" creates a new Stack object from an array of elements.
+     * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.
+     * @returns {Stack} The method is returning a new instance of the Stack class, initialized with the elements from the input
+     * array.
+     */
+    static fromArray(elements) {
+        return new Stack(elements);
+    }
+    /**
+     * The function checks if an array is empty and returns a boolean value.
+     * @returns A boolean value indicating whether the `_elements` array is empty or not.
+     */
+    isEmpty() {
+        return this._elements.length === 0;
+    }
+    /**
+     * The size() function returns the number of elements in an array.
+     * @returns The size of the elements array.
+     */
+    size() {
+        return this._elements.length;
+    }
+    /**
+     * The `peek` function returns the last element of an array, or null if the array is empty.
+     * @returns The `peek()` function returns the last element of the `_elements` array, or `null` if the array is empty.
+     */
+    peek() {
+        if (this.isEmpty())
+            return null;
+        return this._elements[this._elements.length - 1];
+    }
+    /**
+     * The push function adds an element to the stack and returns the updated stack.
+     * @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) {
+        this._elements.push(element);
+        return this;
+    }
+    /**
+     * The `pop` function removes and returns the last element from an array, or returns null if the array is empty.
+     * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
+     * array is empty, it returns `null`.
+     */
+    pop() {
+        if (this.isEmpty())
+            return null;
+        return this._elements.pop() || null;
+    }
+    /**
+     * The toArray function returns a copy of the elements in an array.
+     * @returns An array of type E.
+     */
+    toArray() {
+        return this._elements.slice();
+    }
+    /**
+     * The clear function clears the elements array.
+     */
+    clear() {
+        this._elements = [];
+    }
+    /**
+     * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
+     * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
+     */
+    clone() {
+        return new Stack(this._elements.slice());
+    }
+}
+exports.Stack = Stack;

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

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

package/dist/data-structures/tree/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./tree"), exports);

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

@@ -0,0 +1,14 @@
+export declare class TreeNode<V = any> {
+    constructor(key: string, value?: V, children?: TreeNode<V>[]);
+    private _key;
+    get key(): string;
+    set key(value: string);
+    private _value?;
+    get value(): V | undefined;
+    set value(value: V | undefined);
+    private _children?;
+    get children(): TreeNode<V>[] | undefined;
+    set children(value: TreeNode<V>[] | undefined);
+    addChildren(children: TreeNode<V> | TreeNode<V>[]): void;
+    getHeight(): number;
+}

package/dist/data-structures/tree/tree.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeNode = void 0;
+class TreeNode {
+    constructor(key, value, children) {
+        this._key = key;
+        this._value = value || undefined;
+        this._children = children || [];
+    }
+    get key() {
+        return this._key;
+    }
+    set key(value) {
+        this._key = value;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+    }
+    get children() {
+        return this._children;
+    }
+    set children(value) {
+        this._children = value;
+    }
+    addChildren(children) {
+        if (!this.children) {
+            this.children = [];
+        }
+        if (children instanceof TreeNode) {
+            this.children.push(children);
+        }
+        else {
+            this.children = this.children.concat(children);
+        }
+    }
+    getHeight() {
+        let maxDepth = 0;
+        if (this) {
+            const bfs = (node, level) => {
+                if (level > maxDepth) {
+                    maxDepth = level;
+                }
+                const { children } = node;
+                if (children) {
+                    for (let i = 0, len = children.length; i < len; i++) {
+                        bfs(children[i], level + 1);
+                    }
+                }
+            };
+            bfs(this, 0);
+        }
+        return maxDepth;
+    }
+}
+exports.TreeNode = TreeNode;

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./trie"), exports);

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

@@ -0,0 +1,84 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+/**
+ * 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.
+ */
+export declare class TrieNode {
+    constructor(key: string);
+    private _key;
+    get key(): string;
+    set key(v: string);
+    protected _children: Map<string, TrieNode>;
+    get children(): Map<string, TrieNode>;
+    set children(v: Map<string, TrieNode>);
+    protected _isEnd: boolean;
+    get isEnd(): boolean;
+    set isEnd(v: boolean);
+}
+/**
+ * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
+ */
+export declare class Trie {
+    private readonly _caseSensitive;
+    constructor(words?: string[], caseSensitive?: boolean);
+    protected _root: TrieNode;
+    get root(): TrieNode;
+    set root(v: TrieNode);
+    /**
+     * Add a word to the Trie structure.
+     * @param {string} word - The word to add.
+     * @returns {boolean} True if the word was successfully added.
+     */
+    add(word: string): boolean;
+    /**
+     * Check if the Trie contains a given word.
+     * @param {string} word - The word to check for.
+     * @returns {boolean} True if the word is present in the Trie.
+     */
+    has(word: string): boolean;
+    /**
+     * Remove a word from the Trie structure.
+     * @param{string} word - The word to delete.
+     * @returns {boolean} True if the word was successfully removed.
+     */
+    delete(word: string): boolean;
+    getHeight(): number;
+    /**
+     * Check if a given input string has an absolute prefix in the Trie, meaning it's not a complete word.
+     * @param {string} input - The input string to check.
+     * @returns {boolean} True if it's an absolute prefix in the Trie.
+     */
+    hasPurePrefix(input: string): boolean;
+    /**
+     * Check if a given input string is a prefix of any existing word in the Trie, whether as an absolute prefix or a complete word.
+     * @param {string} input - The input string representing the prefix to check.
+     * @returns {boolean} True if it's a prefix in the Trie.
+     */
+    hasPrefix(input: string): boolean;
+    /**
+     * Check if the input string is a common prefix in the Trie, meaning it's a prefix shared by all words in the Trie.
+     * @param {string} input - The input string representing the common prefix to check for.
+     * @returns {boolean} True if it's a common prefix in the Trie.
+     */
+    hasCommonPrefix(input: string): boolean;
+    /**
+     * Get the longest common prefix among all the words stored in the Trie.
+     * @returns {string} The longest common prefix found in the Trie.
+     */
+    getLongestCommonPrefix(): string;
+    /**
+     * The `getAll` function returns an array of all words in a Trie data structure that start with a given prefix.
+     * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
+     * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
+     * @param {number} max - The max count of words will be found
+     * @returns {string[]} an array of strings.
+     */
+    getWords(prefix?: string, max?: number): string[];
+    private _caseProcess;
+}