data-structure-typed 1.21.4 → 1.32.0

package/{dist → lib}/data-structures/queue/queue.d.ts

@@ -3,9 +3,25 @@
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-export declare class Queue<T = number> {
-    protected _nodes: T[];
-    protected _offset: number;
+import { SinglyLinkedList } from '../linked-list';
+export declare class LinkedListQueue<T = any> extends SinglyLinkedList<T> {
+    /**
+     * The enqueue function adds a value to the end of an array.
+     * @param {T} value - The value parameter represents the value that you want to add to the queue.
+     */
+    enqueue(value: T): void;
+    /**
+     * 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(): T | undefined;
+    /**
+     * 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(): T | undefined;
+}
+export declare class Queue<T = any> {
     /**
      * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
      * @param {T[]} [elements] - The `elements` parameter is an optional array of elements of type `T`. If provided, it
@@ -13,6 +29,17 @@ export declare class Queue<T = number> {
      * initialized as an empty array.
      */
     constructor(elements?: T[]);
+    private _nodes;
+    get nodes(): T[];
+    set nodes(value: T[]);
+    private _offset;
+    get offset(): number;
+    set offset(value: number);
+    /**
+     * 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(): number;
     /**
      * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
      * @public
@@ -23,34 +50,40 @@ export declare class Queue<T = number> {
      */
     static fromArray<T>(elements: T[]): Queue<T>;
     /**
-     * The add function adds an element to the end of the queue and returns the updated queue.Adds an element at the back of the queue.
+     * 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 {T} element - The `element` parameter represents the element that you want to add to the queue.
      * @returns The `add` method is returning a `Queue<T>` object.
      */
-    add(element: T): Queue<T>;
+    push(element: T): Queue<T>;
     /**
-     * The `poll` function removes and returns the first element in the queue, and adjusts the internal data structure if
+     * 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 `poll()` returns either the first element in the queue or `null` if the queue is empty.
+     * @returns The function `shift()` returns either the first element in the queue or `null` if the queue is empty.
      */
-    poll(): T | null;
+    shift(): T | undefined;
     /**
      * 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(): T | null;
+    peek(): T | 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(): T | null;
+    peekLast(): T | undefined;
     /**
-     * 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.
+     * The enqueue function adds a value to the end of a queue.
+     * @param {T} value - The value parameter represents the value that you want to add to the queue.
+     */
+    enqueue(value: T): void;
+    /**
+     * 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 T or null.
      */
-    size(): number;
+    dequeue(): T | undefined;
+    getAt(index: number): T | undefined;
     /**
      * 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.
@@ -70,4 +103,5 @@ export declare class Queue<T = number> {
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
      */
     clone(): Queue<T>;
+    [Symbol.iterator](): Generator<T, void, unknown>;
 }

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

@@ -0,0 +1,165 @@
+/**
+ * @license MIT
+ * @copyright Tyler Zeng <zrwusa@gmail.com>
+ * @class
+ */
+import { SinglyLinkedList } from '../linked-list';
+export class LinkedListQueue extends SinglyLinkedList {
+    /**
+     * The enqueue function adds a value to the end of an array.
+     * @param {T} 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;
+    }
+}
+export class Queue {
+    /**
+     * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
+     * @param {T[]} [elements] - The `elements` parameter is an optional array of elements of type `T`. 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 {T[]} elements - The "elements" parameter is an array of elements of type T.
+     * @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 {T} element - The `element` parameter represents the element that you want to add to the queue.
+     * @returns The `add` method is returning a `Queue<T>` 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 remove 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 {T} 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 T 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 T 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;
+        }
+    }
+}

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

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

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

@@ -0,0 +1,87 @@
+/**
+ * @license MIT
+ * @copyright Tyler Zeng <zrwusa@gmail.com>
+ * @class
+ */
+export class Stack {
+    /**
+     * The constructor initializes an array of elements, which can be provided as an optional parameter.
+     * @param {T[]} [elements] - The `elements` parameter is an optional parameter of type `T[]`, which represents an array
+     * of elements of type `T`. 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 {T[]} elements - The `elements` parameter is an array of elements of type `T`.
+     * @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 {T} element - The parameter "element" is of type T, which means it can be any data type.
+     * @returns The `push` method is returning the updated `Stack<T>` 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 T.
+     */
+    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());
+    }
+}

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

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

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

@@ -0,0 +1,56 @@
+export class TreeNode {
+    constructor(id, value, children) {
+        this._id = id;
+        this._value = value || undefined;
+        this._children = children || [];
+    }
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = 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() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const beginRoot = this;
+        let maxDepth = 1;
+        if (beginRoot) {
+            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(beginRoot, 1);
+        }
+        return maxDepth;
+    }
+}

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

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

package/lib/data-structures/trie/trie.js

@@ -0,0 +1,205 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export class TrieNode {
+    constructor(v) {
+        this._val = v;
+        this._isEnd = false;
+        this._children = new Map();
+    }
+    get val() {
+        return this._val;
+    }
+    set val(v) {
+        this._val = v;
+    }
+    get children() {
+        return this._children;
+    }
+    set children(v) {
+        this._children = v;
+    }
+    get isEnd() {
+        return this._isEnd;
+    }
+    set isEnd(v) {
+        this._isEnd = v;
+    }
+}
+export class Trie {
+    constructor(words) {
+        this._root = new TrieNode('');
+        if (words) {
+            for (const i of words) {
+                this.add(i);
+            }
+        }
+    }
+    get root() {
+        return this._root;
+    }
+    set root(v) {
+        this._root = v;
+    }
+    add(word) {
+        let cur = this._root;
+        for (const c of word) {
+            let nodeC = cur.children.get(c);
+            if (!nodeC) {
+                nodeC = new TrieNode(c);
+                cur.children.set(c, nodeC);
+            }
+            cur = nodeC;
+        }
+        cur.isEnd = true;
+        return true;
+    }
+    has(input) {
+        let cur = this._root;
+        for (const c of input) {
+            const nodeC = cur.children.get(c);
+            if (!nodeC)
+                return false;
+            cur = nodeC;
+        }
+        return cur.isEnd;
+    }
+    remove(word) {
+        let isDeleted = false;
+        const dfs = (cur, i) => {
+            const char = word[i];
+            const child = cur.children.get(char);
+            if (child) {
+                if (i === word.length - 1) {
+                    if (child.isEnd) {
+                        if (child.children.size > 0) {
+                            child.isEnd = false;
+                        }
+                        else {
+                            cur.children.delete(char);
+                        }
+                        isDeleted = true;
+                        return true;
+                    }
+                    return false;
+                }
+                const res = dfs(child, i + 1);
+                if (res && !cur.isEnd && child.children.size === 0) {
+                    cur.children.delete(char);
+                    return true;
+                }
+                return false;
+            }
+            return false;
+        };
+        dfs(this.root, 0);
+        return isDeleted;
+    }
+    // --- start additional methods ---
+    /**
+     * The function checks if a given input string has an absolute prefix in a tree data structure.Only can present as a prefix, not a word
+     * @param {string} input - The input parameter is a string that represents the input value for the function.
+     * @returns a boolean value.
+     */
+    isAbsPrefix(input) {
+        let cur = this._root;
+        for (const c of input) {
+            const nodeC = cur.children.get(c);
+            if (!nodeC)
+                return false;
+            cur = nodeC;
+        }
+        return !cur.isEnd;
+    }
+    /**
+     * The function checks if a given input string is a prefix of any existing string in a tree structure.Can present as a abs prefix or word
+     * @param {string} input - The input parameter is a string that represents the prefix we want to check.
+     * @returns a boolean value.
+     */
+    isPrefix(input) {
+        let cur = this._root;
+        for (const c of input) {
+            const nodeC = cur.children.get(c);
+            if (!nodeC)
+                return false;
+            cur = nodeC;
+        }
+        return true;
+    }
+    /**
+     * The function checks if the input string is a common prefix in a Trie data structure.Check if the input string is the common prefix of all the words
+     * @param {string} input - The input parameter is a string that represents the common prefix that we want to check for
+     * in the Trie data structure.
+     * @returns a boolean value indicating whether the input string is a common prefix in the Trie data structure.
+     */
+    isCommonPrefix(input) {
+        let commonPre = '';
+        const dfs = (cur) => {
+            commonPre += cur.val;
+            if (commonPre === input)
+                return;
+            if (cur.isEnd)
+                return;
+            if (cur && cur.children && cur.children.size === 1)
+                dfs(Array.from(cur.children.values())[0]);
+            else
+                return;
+        };
+        dfs(this._root);
+        return commonPre === input;
+    }
+    /**
+     * The function `getLongestCommonPrefix` returns the longest common prefix among all the words stored in a Trie data
+     * structure.
+     * @returns The function `getLongestCommonPrefix` returns a string, which is the longest common prefix found in the
+     * Trie.
+     */
+    getLongestCommonPrefix() {
+        let commonPre = '';
+        const dfs = (cur) => {
+            commonPre += cur.val;
+            if (cur.isEnd)
+                return;
+            if (cur && cur.children && cur.children.size === 1)
+                dfs(Array.from(cur.children.values())[0]);
+            else
+                return;
+        };
+        dfs(this._root);
+        return commonPre;
+    }
+    /**
+     * The `getAll` function returns an array of all words in a Trie data structure that start with a given prefix.
+     * @param [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.
+     * @returns an array of strings.
+     */
+    getAll(prefix = '') {
+        const words = [];
+        function dfs(node, word) {
+            for (const char of node.children.keys()) {
+                const charNode = node.children.get(char);
+                if (charNode !== undefined) {
+                    dfs(charNode, word.concat(char));
+                }
+            }
+            if (node.isEnd) {
+                words.push(word);
+            }
+        }
+        let startNode = this._root;
+        if (prefix) {
+            for (const c of prefix) {
+                const nodeC = startNode.children.get(c);
+                if (nodeC)
+                    startNode = nodeC;
+            }
+        }
+        dfs(startNode, prefix);
+        return words;
+    }
+}

package/lib/index.js

@@ -0,0 +1,4 @@
+export * from './data-structures';
+export * from './utils';
+export * from './interfaces';
+export * from './types';

package/{dist → lib}/interfaces/avl-tree.d.ts

@@ -1,16 +1,8 @@
 import { AVLTreeNode } from '../data-structures';
 import { IBST, IBSTNode } from './bst';
 import { BinaryTreeDeletedResult, BinaryTreeNodeId } from '../types';
-export interface IAVLTreeNode<T, NEIGHBOR extends IAVLTreeNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
-}
+export type IAVLTreeNode<T, NEIGHBOR extends IAVLTreeNode<T, NEIGHBOR>> = IBSTNode<T, NEIGHBOR>;
 export interface IAVLTree<N extends AVLTreeNode<N['val'], N>> extends IBST<N> {
     add(id: BinaryTreeNodeId, val?: N['val'] | null): N | null | undefined;
     remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): BinaryTreeDeletedResult<N>[];
-    balanceFactor(node: N): number;
-    updateHeight(node: N): void;
-    balancePath(node: N): void;
-    balanceLL(A: N): void;
-    balanceLR(A: N): void;
-    balanceRR(A: N): void;
-    balanceRL(A: N): void;
 }

package/lib/interfaces/binary-tree.d.ts

@@ -0,0 +1,4 @@
+import { BinaryTreeNode } from '../data-structures';
+import { IAbstractBinaryTree, IAbstractBinaryTreeNode } from './abstract-binary-tree';
+export type IBinaryTreeNode<T, NEIGHBOR extends IBinaryTreeNode<T, NEIGHBOR>> = IAbstractBinaryTreeNode<T, NEIGHBOR>;
+export type IBinaryTree<N extends BinaryTreeNode<N['val'], N>> = IAbstractBinaryTree<N>;

package/{dist → lib}/interfaces/bst.d.ts

@@ -1,8 +1,7 @@
 import { BSTNode } from '../data-structures';
 import { IBinaryTree, IBinaryTreeNode } from './binary-tree';
 import { BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName } from '../types';
-export interface IBSTNode<T, NEIGHBOR extends IBSTNode<T, NEIGHBOR>> extends IBinaryTreeNode<T, NEIGHBOR> {
-}
+export type IBSTNode<T, NEIGHBOR extends IBSTNode<T, NEIGHBOR>> = IBinaryTreeNode<T, NEIGHBOR>;
 export interface IBST<N extends BSTNode<N['val'], N>> extends IBinaryTree<N> {
     createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
     add(id: BinaryTreeNodeId, val?: N['val'] | null, count?: number): N | null | undefined;

package/lib/interfaces/heap.js

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