data-structure-typed 0.9.16 → 1.3.0

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

@@ -1,48 +1,91 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queue = void 0;
+exports.ArrayQueue = exports.Queue = void 0;
 /**
  * @license MIT
- * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
+ * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-var Queue = /** @class */ (function () {
+const linked_list_1 = require("../linked-list");
+class Queue extends linked_list_1.SinglyLinkedList {
     /**
-     * Creates a queue.
-     * @param {array} [elements]
+     * 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.
      */
-    function Queue(elements) {
+    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;
+    }
+    *[Symbol.iterator]() {
+        let current = this.head;
+        while (current) {
+            yield current.val;
+            current = current.next;
+        }
+    }
+}
+exports.Queue = Queue;
+class ArrayQueue {
+    /**
+     * 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;
     }
     /**
-     * Creates a queue from an existing array.
+     * 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 {array} elements
-     * @return {Queue}
+     * @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.
      */
-    Queue.fromArray = function (elements) {
-        return new Queue(elements);
-    };
+    static fromArray(elements) {
+        return new ArrayQueue(elements);
+    }
     /**
-     * Adds an element at the back of the queue.
-     * @public
-     * @param {any} element
+     * 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.
      */
-    Queue.prototype.offer = function (element) {
+    push(element) {
         this._nodes.push(element);
         return this;
-    };
+    }
     /**
-     * Dequeues the front element in the queue.
-     * @public
-     * @returns {any}
+     * 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.
      */
-    Queue.prototype.poll = function () {
-        if (this.size() === 0)
+    shift() {
+        if (this.size === 0)
             return null;
-        var first = this.peek();
+        const first = this.peek();
         this._offset += 1;
         if (this._offset * 2 < this._nodes.length)
             return first;
@@ -51,63 +94,64 @@ var Queue = /** @class */ (function () {
         this._nodes = this._nodes.slice(this._offset);
         this._offset = 0;
         return first;
-    };
+    }
     /**
-     * Returns the front element of the queue.
-     * @public
-     * @returns {any}
+     * 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`.
      */
-    Queue.prototype.peek = function () {
-        return this.size() > 0 ? this._nodes[this._offset] : null;
-    };
+    peek() {
+        return this.size > 0 ? this._nodes[this._offset] : null;
+    }
     /**
-     * Returns the back element of the queue.
-     * @public
-     * @returns {any}
+     * 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`.
      */
-    Queue.prototype.peekLast = function () {
-        return this.size() > 0 ? this._nodes[this._nodes.length - 1] : null;
-    };
+    peekLast() {
+        return this.size > 0 ? this._nodes[this._nodes.length - 1] : null;
+    }
     /**
-     * Returns the number of elements in the queue.
-     * @public
-     * @returns {number}
+     * 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.
      */
-    Queue.prototype.size = function () {
-        return this._nodes.length - this._offset;
-    };
+    enqueue(value) {
+        this.push(value);
+    }
     /**
-     * Checks if the queue is empty.
-     * @public
-     * @returns {boolean}
+     * 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.
      */
-    Queue.prototype.isEmpty = function () {
-        return this.size() === 0;
-    };
+    dequeue() {
+        return this.shift();
+    }
     /**
-     * Returns the remaining elements in the queue as an array.
-     * @public
-     * @returns {array}
+     * 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.
      */
-    Queue.prototype.toArray = function () {
+    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);
-    };
+    }
     /**
-     * Clears the queue.
-     * @public
+     * The clear function resets the nodes array and offset to their initial values.
      */
-    Queue.prototype.clear = function () {
+    clear() {
         this._nodes = [];
         this._offset = 0;
-    };
+    }
     /**
-     * Creates a shallow copy of the queue.
-     * @public
-     * @return {Queue}
+     * 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.
      */
-    Queue.prototype.clone = function () {
-        return new Queue(this._nodes.slice(this._offset));
-    };
-    return Queue;
-}());
-exports.Queue = Queue;
+    clone() {
+        return new ArrayQueue(this._nodes.slice(this._offset));
+    }
+}
+exports.ArrayQueue = ArrayQueue;

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

@@ -1,68 +1,63 @@
 /**
  * @license MIT
- * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
+ * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-export declare class Stack<T> {
+export declare class Stack<T = number> {
     protected _elements: T[];
     /**
-     * Creates a stack.
-     * @param {array} [elements]
+     * 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?: T[]);
     /**
-     * Creates a stack from an existing array
-     * @public
-     * @static
-     * @param {array} [elements]
-     * @return {Stack}
+     * 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<T>(elements: T[]): Stack<T>;
     /**
-     * Checks if the stack is empty.
-     * @public
-     * @returns {boolean}
+     * 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;
     /**
-     * Returns the number of elements in the stack.
-     * @public
-     * @returns {number}
+     * The size() function returns the number of elements in an array.
+     * @returns The size of the elements array.
      */
     size(): number;
     /**
-     * Returns the top element in the stack.
-     * @public
-     * @returns {object}
+     * 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(): T | null;
     /**
-     * Adds an element to the top of the stack.
-     * @public
-     * @param {object} element
+     * 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: T): Stack<T>;
     /**
-     * Removes and returns the top element in the stack.
-     * @public
-     * @returns {object}
+     * 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(): T | null;
     /**
-     * Returns the remaining elements as an array.
-     * @public
-     * @returns {array}
+     * The toArray function returns a copy of the elements in an array.
+     * @returns An array of type T.
      */
     toArray(): T[];
     /**
-     * Clears all elements from the stack.
-     * @public
+     * The clear function clears the elements array.
      */
     clear(): void;
     /**
-     * Creates a shallow copy from the stack.
-     * @public
-     * @return {Stack}
+     * 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<T>;
 }

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

@@ -3,95 +3,89 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Stack = void 0;
 /**
  * @license MIT
- * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
+ * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-var Stack = /** @class */ (function () {
+class Stack {
     /**
-     * Creates a stack.
-     * @param {array} [elements]
+     * 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
      */
-    function Stack(elements) {
+    constructor(elements) {
         this._elements = Array.isArray(elements) ? elements : [];
     }
     /**
-     * Creates a stack from an existing array
-     * @public
-     * @static
-     * @param {array} [elements]
-     * @return {Stack}
+     * 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.
      */
-    Stack.fromArray = function (elements) {
+    static fromArray(elements) {
         return new Stack(elements);
-    };
+    }
     /**
-     * Checks if the stack is empty.
-     * @public
-     * @returns {boolean}
+     * 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.
      */
-    Stack.prototype.isEmpty = function () {
+    isEmpty() {
         return this._elements.length === 0;
-    };
+    }
     /**
-     * Returns the number of elements in the stack.
-     * @public
-     * @returns {number}
+     * The size() function returns the number of elements in an array.
+     * @returns The size of the elements array.
      */
-    Stack.prototype.size = function () {
+    size() {
         return this._elements.length;
-    };
+    }
     /**
-     * Returns the top element in the stack.
-     * @public
-     * @returns {object}
+     * 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.
      */
-    Stack.prototype.peek = function () {
+    peek() {
         if (this.isEmpty())
             return null;
         return this._elements[this._elements.length - 1];
-    };
+    }
     /**
-     * Adds an element to the top of the stack.
-     * @public
-     * @param {object} element
+     * 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.
      */
-    Stack.prototype.push = function (element) {
+    push(element) {
         this._elements.push(element);
         return this;
-    };
+    }
     /**
-     * Removes and returns the top element in the stack.
-     * @public
-     * @returns {object}
+     * 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`.
      */
-    Stack.prototype.pop = function () {
+    pop() {
         if (this.isEmpty())
             return null;
         return this._elements.pop() || null;
-    };
+    }
     /**
-     * Returns the remaining elements as an array.
-     * @public
-     * @returns {array}
+     * The toArray function returns a copy of the elements in an array.
+     * @returns An array of type T.
      */
-    Stack.prototype.toArray = function () {
+    toArray() {
         return this._elements.slice();
-    };
+    }
     /**
-     * Clears all elements from the stack.
-     * @public
+     * The clear function clears the elements array.
      */
-    Stack.prototype.clear = function () {
+    clear() {
         this._elements = [];
-    };
+    }
     /**
-     * Creates a shallow copy from the stack.
-     * @public
-     * @return {Stack}
+     * 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.
      */
-    Stack.prototype.clone = function () {
+    clone() {
         return new Stack(this._elements.slice());
-    };
-    return Stack;
-}());
+    }
+}
 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<T = any> {
+    constructor(id: string, value?: T, children?: TreeNode<T>[]);
+    private _id;
+    get id(): string;
+    set id(value: string);
+    private _value?;
+    get value(): T | undefined;
+    set value(value: T | undefined);
+    private _children?;
+    get children(): TreeNode<T>[] | undefined;
+    set children(value: TreeNode<T>[] | undefined);
+    addChildren(children: TreeNode<T> | TreeNode<T>[]): void;
+    getHeight(): number;
+}

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeNode = void 0;
+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;
+    }
+}
+exports.TreeNode = TreeNode;

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

@@ -1,38 +1,61 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 export declare class TrieNode {
-    protected _value: string;
     constructor(v: string);
+    private _val;
+    get val(): string;
+    set val(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);
-    get val(): string;
-    set val(v: string);
 }
 export declare class Trie {
     constructor(words?: string[]);
     protected _root: TrieNode;
     get root(): TrieNode;
     set root(v: TrieNode);
-    put(word: string): boolean;
+    add(word: string): boolean;
     has(input: string): boolean;
     remove(word: string): boolean;
     /**
-     * Only can present as a prefix, not a word
-     * @param input
+     * 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: string): boolean;
     /**
-     * Can present as a abs prefix or word
-     * @param input
+     * 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: string): boolean;
     /**
-     * Check if the input string is the common prefix of all the words
-     * @param input
+     * 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: string): boolean;
+    /**
+     * 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(): string;
+    /**
+     * 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?: string): string[];
 }