data-structure-typed 0.8.18 → 1.12.9

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

@@ -3,95 +3,90 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Stack = void 0;
 /**
  * @license MIT
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
- *
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-class Stack {
+var Stack = /** @class */ (function () {
     /**
-     * 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) {
+    function Stack(elements) {
         this._elements = Array.isArray(elements) ? elements : [];
     }
     /**
-     * Checks if the stack is empty.
-     * @public
-     * @returns {boolean}
+     * 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.
      */
-    isEmpty() {
+    Stack.fromArray = function (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.
+     */
+    Stack.prototype.isEmpty = function () {
         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.
      */
-    size() {
+    Stack.prototype.size = function () {
         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.
      */
-    peek() {
+    Stack.prototype.peek = function () {
         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.
      */
-    push(element) {
+    Stack.prototype.push = function (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`.
      */
-    pop() {
+    Stack.prototype.pop = function () {
         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.
      */
-    toArray() {
+    Stack.prototype.toArray = function () {
         return this._elements.slice();
-    }
+    };
     /**
-     * Clears all elements from the stack.
-     * @public
+     * The clear function clears the elements array.
      */
-    clear() {
+    Stack.prototype.clear = function () {
         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.
      */
-    clone() {
+    Stack.prototype.clone = function () {
         return new Stack(this._elements.slice());
-    }
-    /**
-     * Creates a stack from an existing array
-     * @public
-     * @static
-     * @param {array} [elements]
-     * @return {Stack}
-     */
-    static fromArray(elements) {
-        return new Stack(elements);
-    }
-}
+    };
+    return Stack;
+}());
 exports.Stack = Stack;

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

@@ -1,28 +1,58 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 export declare class TrieNode {
+    protected _value: string;
+    constructor(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);
-    constructor();
-    put(input: string): boolean;
+    put(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 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;
+    /**
+     * 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[];
 }

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

@@ -1,63 +1,140 @@
 "use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Trie = exports.TrieNode = void 0;
-class TrieNode {
-    constructor() {
-        this._children = new Map();
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+var TrieNode = /** @class */ (function () {
+    function TrieNode(v) {
+        this._value = v;
         this._isEnd = false;
+        this._children = new Map();
     }
-    get children() {
-        return this._children;
-    }
-    set children(v) {
-        this._children = v;
-    }
-    get isEnd() {
-        return this._isEnd;
-    }
-    set isEnd(v) {
-        this._isEnd = v;
-    }
-}
+    Object.defineProperty(TrieNode.prototype, "children", {
+        get: function () {
+            return this._children;
+        },
+        set: function (v) {
+            this._children = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TrieNode.prototype, "isEnd", {
+        get: function () {
+            return this._isEnd;
+        },
+        set: function (v) {
+            this._isEnd = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TrieNode.prototype, "val", {
+        get: function () {
+            return this._value;
+        },
+        set: function (v) {
+            this._value = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return TrieNode;
+}());
 exports.TrieNode = TrieNode;
-class Trie {
-    get root() {
-        return this._root;
-    }
-    set root(v) {
-        this._root = v;
-    }
-    constructor() {
-        this._root = new TrieNode();
+var Trie = /** @class */ (function () {
+    function Trie(words) {
+        var e_1, _a;
+        this._root = new TrieNode('');
+        if (words) {
+            try {
+                for (var words_1 = __values(words), words_1_1 = words_1.next(); !words_1_1.done; words_1_1 = words_1.next()) {
+                    var i = words_1_1.value;
+                    this.put(i);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (words_1_1 && !words_1_1.done && (_a = words_1.return)) _a.call(words_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
     }
-    put(input) {
-        let cur = this._root;
-        for (const c of input) {
-            let nodeC = cur.children.get(c);
-            if (!nodeC) {
-                nodeC = new TrieNode();
-                cur.children.set(c, nodeC);
-            }
-            cur = nodeC;
+    Object.defineProperty(Trie.prototype, "root", {
+        get: function () {
+            return this._root;
+        },
+        set: function (v) {
+            this._root = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Trie.prototype.put = function (word) {
+        var e_2, _a;
+        var cur = this._root;
+        try {
+            for (var word_1 = __values(word), word_1_1 = word_1.next(); !word_1_1.done; word_1_1 = word_1.next()) {
+                var c = word_1_1.value;
+                var nodeC = cur.children.get(c);
+                if (!nodeC) {
+                    nodeC = new TrieNode(c);
+                    cur.children.set(c, nodeC);
+                }
+                cur = nodeC;
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (word_1_1 && !word_1_1.done && (_a = word_1.return)) _a.call(word_1);
+            }
+            finally { if (e_2) throw e_2.error; }
         }
         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;
+    };
+    Trie.prototype.has = function (input) {
+        var e_3, _a;
+        var cur = this._root;
+        try {
+            for (var input_1 = __values(input), input_1_1 = input_1.next(); !input_1_1.done; input_1_1 = input_1.next()) {
+                var c = input_1_1.value;
+                var nodeC = cur.children.get(c);
+                if (!nodeC)
+                    return false;
+                cur = nodeC;
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (input_1_1 && !input_1_1.done && (_a = input_1.return)) _a.call(input_1);
+            }
+            finally { if (e_3) throw e_3.error; }
         }
         return cur.isEnd;
-    }
-    remove(word) {
-        let isDeleted = false;
-        const dfs = (cur, i) => {
-            const char = word[i];
-            const child = cur.children.get(char);
+    };
+    Trie.prototype.remove = function (word) {
+        var isDeleted = false;
+        var dfs = function (cur, i) {
+            var char = word[i];
+            var child = cur.children.get(char);
             if (child) {
                 if (i === word.length - 1) {
                     if (child.isEnd) {
@@ -72,7 +149,7 @@ class Trie {
                     }
                     return false;
                 }
-                const res = dfs(child, i + 1);
+                var res = dfs(child, i + 1);
                 if (res && !cur.isEnd && child.children.size === 0) {
                     cur.children.delete(char);
                     return true;
@@ -83,59 +160,155 @@ class Trie {
         };
         dfs(this.root, 0);
         return isDeleted;
-    }
+    };
     // --- start additional methods ---
     /**
-     * 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) {
-        let cur = this._root;
-        for (const c of input) {
-            const nodeC = cur.children.get(c);
-            if (!nodeC)
-                return false;
-            cur = nodeC;
+    Trie.prototype.isAbsPrefix = function (input) {
+        var e_4, _a;
+        var cur = this._root;
+        try {
+            for (var input_2 = __values(input), input_2_1 = input_2.next(); !input_2_1.done; input_2_1 = input_2.next()) {
+                var c = input_2_1.value;
+                var nodeC = cur.children.get(c);
+                if (!nodeC)
+                    return false;
+                cur = nodeC;
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (input_2_1 && !input_2_1.done && (_a = input_2.return)) _a.call(input_2);
+            }
+            finally { if (e_4) throw e_4.error; }
         }
         return !cur.isEnd;
-    }
+    };
     /**
-     * Can present as a 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) {
-        let cur = this._root;
-        for (const c of input) {
-            const nodeC = cur.children.get(c);
-            if (!nodeC)
-                return false;
-            cur = nodeC;
+    Trie.prototype.isPrefix = function (input) {
+        var e_5, _a;
+        var cur = this._root;
+        try {
+            for (var input_3 = __values(input), input_3_1 = input_3.next(); !input_3_1.done; input_3_1 = input_3.next()) {
+                var c = input_3_1.value;
+                var nodeC = cur.children.get(c);
+                if (!nodeC)
+                    return false;
+                cur = nodeC;
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (input_3_1 && !input_3_1.done && (_a = input_3.return)) _a.call(input_3);
+            }
+            finally { if (e_5) throw e_5.error; }
         }
         return true;
-    }
-    getAll(prefix = '') {
-        const words = [];
+    };
+    /**
+     * 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.
+     */
+    Trie.prototype.isCommonPrefix = function (input) {
+        var commonPre = '';
+        var dfs = function (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.
+     */
+    Trie.prototype.getLongestCommonPrefix = function () {
+        var commonPre = '';
+        var dfs = function (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.
+     */
+    Trie.prototype.getAll = function (prefix) {
+        var e_6, _a;
+        if (prefix === void 0) { prefix = ''; }
+        var 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));
+            var e_7, _a;
+            try {
+                for (var _b = __values(node.children.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var char = _c.value;
+                    var charNode = node.children.get(char);
+                    if (charNode !== undefined) {
+                        dfs(charNode, word.concat(char));
+                    }
                 }
             }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
             if (node.isEnd) {
                 words.push(word);
             }
         }
-        let startNode = this._root;
+        var startNode = this._root;
         if (prefix) {
-            for (const c of prefix) {
-                const nodeC = startNode.children.get(c);
-                if (nodeC)
-                    startNode = nodeC;
+            try {
+                for (var prefix_1 = __values(prefix), prefix_1_1 = prefix_1.next(); !prefix_1_1.done; prefix_1_1 = prefix_1.next()) {
+                    var c = prefix_1_1.value;
+                    var nodeC = startNode.children.get(c);
+                    if (nodeC)
+                        startNode = nodeC;
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (prefix_1_1 && !prefix_1_1.done && (_a = prefix_1.return)) _a.call(prefix_1);
+                }
+                finally { if (e_6) throw e_6.error; }
             }
         }
         dfs(startNode, prefix);
         return words;
-    }
-}
+    };
+    return Trie;
+}());
 exports.Trie = Trie;

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

@@ -0,0 +1,29 @@
+export type VertexId = string | number;
+export type DijkstraResult<V> = {
+    distMap: Map<V, number>;
+    preMap: Map<V, V | null>;
+    seen: Set<V>;
+    paths: V[][];
+    minDist: number;
+    minPath: V[];
+} | null;
+export interface IGraph<V, E> {
+    containsVertex(vertexOrId: V | VertexId): boolean;
+    getVertex(vertexOrId: VertexId | V): V | null;
+    getVertexId(vertexOrId: V | VertexId): VertexId;
+    vertexSet(): Map<VertexId, V>;
+    addVertex(v: V): boolean;
+    removeVertex(vertexOrId: V | VertexId): boolean;
+    removeAllVertices(vertices: V[] | VertexId[]): boolean;
+    degreeOf(vertexOrId: V | VertexId): number;
+    edgesOf(vertexOrId: V | VertexId): E[];
+    containsEdge(src: V | VertexId, dest: V | VertexId): boolean;
+    getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    edgeSet(): E[];
+    addEdge(edge: E): boolean;
+    removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    removeEdge(edge: E): E | null;
+    setEdgeWeight(srcOrId: V | VertexId, destOrId: V | VertexId, weight: number): boolean;
+    getMinPathBetween(v1: V | VertexId, v2: V | VertexId, isWeight?: boolean): V[] | null;
+    getNeighbors(vertexOrId: V | VertexId): V[];
+}

package/dist/data-structures/types/abstract-graph.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,5 @@
+import { AVLTreeNode } from '../binary-tree';
+export interface AVLTreeDeleted<T> {
+    deleted: AVLTreeNode<T> | null;
+    needBalanced: AVLTreeNode<T> | null;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,16 @@
+import { BinaryTreeNode } from '../binary-tree';
+export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
+export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
+export type DFSOrderPattern = 'in' | 'pre' | 'post';
+export type BinaryTreeNodeId = number;
+export type BinaryTreeDeleted<T> = {
+    deleted: BinaryTreeNode<T> | null | undefined;
+    needBalanced: BinaryTreeNode<T> | null;
+};
+export type ResultByProperty<T> = T | BinaryTreeNode<T> | number | BinaryTreeNodeId;
+export type ResultsByProperty<T> = ResultByProperty<T>[];
+export interface BinaryTreeNodeObj<T> {
+    id: BinaryTreeNodeId;
+    val: T;
+    count?: number;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });