data-structure-typed 1.17.4 → 1.18.5

package/backup/recursive-type/src/data-structures/trie/trie.ts

@@ -0,0 +1,227 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export class TrieNode {
+
+    constructor(v: string) {
+        this._val = v;
+        this._isEnd = false;
+        this._children = new Map<string, TrieNode>();
+    }
+
+    private _val;
+
+    get val(): string {
+        return this._val;
+    }
+
+    set val(v: string) {
+        this._val = v;
+    }
+
+    protected _children: Map<string, TrieNode>;
+
+    get children(): Map<string, TrieNode> {
+        return this._children;
+    }
+
+    set children(v: Map<string, TrieNode>) {
+        this._children = v;
+    }
+
+    protected _isEnd: boolean;
+
+    get isEnd(): boolean {
+        return this._isEnd;
+    }
+
+    set isEnd(v: boolean) {
+        this._isEnd = v;
+    }
+
+}
+
+export class Trie {
+    constructor(words?: string[]) {
+        this._root = new TrieNode('');
+        if (words) {
+            for (const i of words) {
+                this.add(i);
+            }
+        }
+    }
+
+    protected _root: TrieNode;
+
+    get root() {
+        return this._root;
+    }
+
+    set root(v: TrieNode) {
+        this._root = v;
+    }
+
+    add(word: string): boolean {
+        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: string): boolean {
+        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: string) {
+        let isDeleted = false;
+        const dfs = (cur: TrieNode, i: number): boolean => {
+            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: string): boolean {
+        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: string): boolean {
+        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: string): boolean {
+        let commonPre = '';
+        const dfs = (cur: TrieNode) => {
+            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(): string {
+        let commonPre = '';
+        const dfs = (cur: TrieNode) => {
+            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 = ''): string[] {
+        const words: string[] = [];
+
+        function dfs(node: TrieNode, word: string) {
+            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;
+    }
+
+    // --- end additional methods ---
+}

package/backup/recursive-type/src/data-structures/types/abstract-graph.ts

@@ -0,0 +1,5 @@
+export type VertexId = string | number;
+export type EdgeId = string;
+export type DijkstraResult<V> =
+    { distMap: Map<V, number>, preMap: Map<V, V | null>, seen: Set<V>, paths: V[][], minDist: number, minPath: V[] }
+    | null;

package/backup/recursive-type/src/data-structures/types/avl-tree.ts

@@ -0,0 +1,8 @@
+import {AVLTreeNode} from '../binary-tree';
+
+export type AVLTreeDeleted<N> = {
+    deleted: N | null;
+    needBalanced: N | null;
+}
+
+export type RecursiveAVLTreeNode<T> = AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T,AVLTreeNode<T,AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

package/backup/recursive-type/src/data-structures/types/binary-tree.ts

@@ -0,0 +1,10 @@
+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<N> = { deleted: N | null | undefined, needBalanced: N | null };
+export type ResultByProperty<N extends BinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeId;
+export type ResultsByProperty<N extends BinaryTreeNode<N['val'], N>> = ResultByProperty<N>[];
+export type RecursiveBinaryTreeNode<T> = BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T,BinaryTreeNode<T,BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

package/backup/recursive-type/src/data-structures/types/bst.ts

@@ -0,0 +1,6 @@
+import {BSTNode} from '../binary-tree';
+import type {BinaryTreeNodeId} from './binary-tree';
+
+export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
+export type BSTDeletedResult<N extends BSTNode<N['val'], N>> = { deleted: N | null, needBalanced: N | null };
+export type RecursiveBSTNode<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T,BSTNode<T,BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

package/backup/recursive-type/src/data-structures/types/directed-graph.ts

@@ -0,0 +1,8 @@
+// 0 means unknown, 1 means visiting, 2 means visited;
+export type TopologicalStatus = 0 | 1 | 2;
+
+export enum TopologicalProperty {
+    VAL = 'VAL',
+    NODE = 'NODE',
+    ID = 'ID',
+}

package/backup/recursive-type/src/data-structures/types/doubly-linked-list.ts

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

package/backup/recursive-type/src/data-structures/types/heap.ts

@@ -0,0 +1,5 @@
+export type HeapOptions<T> = {
+    priority?: (element: T) => number;
+    // TODO there is an idea that support chaining which is for conveniently using the data structure
+    // isChaining? : boolean
+}

package/backup/recursive-type/src/data-structures/types/index.ts

@@ -0,0 +1,12 @@
+export * from './binary-tree';
+export * from './bst';
+export * from './avl-tree';
+export * from './segment-tree';
+export * from './tree-multiset';
+export * from './abstract-graph';
+export * from './directed-graph';
+export * from './priority-queue';
+export * from './heap';
+export * from './singly-linked-list';
+export * from './doubly-linked-list';
+export * from './navigator';

package/backup/recursive-type/src/data-structures/types/navigator.ts

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

package/backup/recursive-type/src/data-structures/types/priority-queue.ts

@@ -0,0 +1,9 @@
+export type PriorityQueueComparator<T> = (a: T, b: T) => number;
+
+export type PriorityQueueOptions<T> = {
+    nodes?: T[];
+    isFix?: boolean;
+    comparator: PriorityQueueComparator<T>;
+}
+
+export type PriorityQueueDFSOrderPattern = 'pre' | 'in' | 'post';

package/backup/recursive-type/src/data-structures/types/segment-tree.ts

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

package/backup/recursive-type/src/data-structures/types/singly-linked-list.ts

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

package/backup/recursive-type/src/data-structures/types/tree-multiset.ts

@@ -0,0 +1 @@
+export type TreeMultiSetDeletedResult<N> = { deleted: N | null, needBalanced: N | null };

package/backup/recursive-type/src/index.ts

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

package/backup/recursive-type/src/utils/index.ts

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

package/backup/recursive-type/src/utils/types/index.ts

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

package/backup/recursive-type/src/utils/types/utils.ts

@@ -0,0 +1,6 @@
+export type ToThunkFn = () => ReturnType<TrlFn>;
+export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: Symbol };
+export type TrlFn = (...args: any[]) => any;
+export type TrlAsyncFn = (...args: any[]) => any;
+
+export type SpecifyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/backup/recursive-type/src/utils/utils.ts

@@ -0,0 +1,78 @@
+export const uuidV4 = function () {
+    return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
+        const r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+};
+
+export const arrayRemove = function <T>(array: T[], predicate: (item: T, index: number, array: T[]) => boolean): T[] {
+    let i = -1, len = array ? array.length : 0;
+    const result = [];
+
+    while (++i < len) {
+        const value = array[i];
+        if (predicate(value, i, array)) {
+            result.push(value);
+            Array.prototype.splice.call(array, i--, 1);
+            len--;
+        }
+    }
+
+    return result;
+};
+
+
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type {Thunk, ToThunkFn, TrlAsyncFn, TrlFn} from './types';
+
+export const THUNK_SYMBOL = Symbol('thunk')
+
+export const isThunk = (fnOrValue: any) => {
+    return typeof fnOrValue === 'function' && fnOrValue.__THUNK__ === THUNK_SYMBOL
+}
+
+export const toThunk = (fn: ToThunkFn): Thunk => {
+    const thunk = () => fn()
+    thunk.__THUNK__ = THUNK_SYMBOL
+    return thunk
+}
+
+export const trampoline = (fn: TrlFn) => {
+    const cont = (...args: [...Parameters<TrlFn>]) => toThunk(() => fn(...args))
+
+    return Object.assign(
+        (...args: [...Parameters<TrlFn>]) => {
+            let result = fn(...args)
+
+            while (isThunk(result) && typeof result === 'function') {
+                result = result()
+            }
+
+            return result
+        },
+        {cont}
+    )
+}
+
+export const trampolineAsync = (fn: TrlAsyncFn) => {
+    const cont = (...args: [...Parameters<TrlAsyncFn>]) => toThunk(() => fn(...args))
+
+    return Object.assign(
+        async (...args: [...Parameters<TrlAsyncFn>]) => {
+            let result = await fn(...args)
+
+            while (isThunk(result) && typeof result === 'function') {
+                result = await result()
+            }
+
+            return result
+        },
+        {cont}
+    )
+}

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

@@ -6,31 +6,25 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeDeleted, BinaryTreeNodeId } from '../types';
-export declare class AVLTreeNode<T> extends BSTNode<T> {
-    /**
-     * The function overrides the clone method of the AVLTreeNode class to create a new AVLTreeNode object with the same
-     * id, value, and count.
-     * @returns The method is returning a new instance of the AVLTreeNode class with the same id, val, and count values as
-     * the current instance.
-     */
-    clone(): AVLTreeNode<T>;
+import type { AVLTreeDeleted, BinaryTreeNodeId, RecursiveAVLTreeNode } from '../types';
+import { IBinaryTreeNode } from '../interfaces';
+export declare class AVLTreeNode<T, FAMILY extends AVLTreeNode<T, FAMILY> = RecursiveAVLTreeNode<T>> extends BSTNode<T, FAMILY> implements IBinaryTreeNode<T, FAMILY> {
 }
-export declare class AVLTree<T> extends BST<T> {
-    createNode(id: BinaryTreeNodeId, val: T, count?: number): AVLTreeNode<T>;
+export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode<number>> extends BST<N> {
+    _createNode(id: BinaryTreeNodeId, val: N['val'], count?: number): N;
     /**
      * The function overrides the add method of a Binary Search Tree to insert a node with a given id and value, and then
      * balances the tree.
      * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that we want to add or
      * update in the AVL tree.
-     * @param {T | null} val - The `val` parameter represents the value that you want to assign to the node with the given
-     * `id`. It can be of type `T` (the generic type) or `null`.
+     * @param {N | null} val - The `val` parameter represents the value that you want to assign to the node with the given
+     * `id`. It can be of type `N` (the generic type) or `null`.
      * @param {number} [count] - The `count` parameter is an optional parameter of type `number`. It represents the number
      * of times the value `val` should be inserted into the AVL tree. If the `count` parameter is not provided, it defaults
      * to `1`, indicating that the value should be inserted once.
-     * @returns The method is returning either an AVLTreeNode<T> object or null.
+     * @returns The method is returning either an N object or null.
      */
-    add(id: BinaryTreeNodeId, val: T | null, count?: number): AVLTreeNode<T> | null;
+    add(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
     /**
      * The function overrides the remove method of the Binary Search Tree class, performs the removal operation, and
      * then balances the tree if necessary.
@@ -39,45 +33,45 @@ export declare class AVLTree<T> extends BST<T> {
      * @param {boolean} [isUpdateAllLeftSum] - The `isUpdateAllLeftSum` parameter is an optional boolean parameter that
      * determines whether the left sum of all nodes in the AVL tree should be updated after removing a node. If
      * `isUpdateAllLeftSum` is set to `true`, the left sum of all nodes will be recalculated.
-     * @returns The method is returning an array of `AVLTreeDeleted<T>` objects.
+     * @returns The method is returning an array of `AVLTreeDeleted<N>` objects.
      */
-    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): AVLTreeDeleted<T>[];
+    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): AVLTreeDeleted<N>[];
     /**
      * The balance factor of a given AVL tree node is calculated by subtracting the height of its left subtree from the
      * height of its right subtree.
-     * @param node - The parameter "node" is of type AVLTreeNode<T>, which represents a node in an AVL tree.
+     * @param node - The parameter "node" is of type N, which represents a node in an AVL tree.
      * @returns The balance factor of the given AVL tree node.
      */
-    balanceFactor(node: AVLTreeNode<T>): number;
+    balanceFactor(node: N): number;
     /**
      * The function updates the height of a node in an AVL tree based on the heights of its left and right subtrees.
      * @param node - The parameter `node` is an AVLTreeNode object, which represents a node in an AVL tree.
      */
-    updateHeight(node: AVLTreeNode<T>): void;
+    updateHeight(node: N): void;
     /**
      * The `balancePath` function balances the AVL tree by performing appropriate rotations based on the balance factor of
      * each node in the path from the given node to the root.
      * @param node - The `node` parameter is an AVLTreeNode object, which represents a node in an AVL tree.
      */
-    balancePath(node: AVLTreeNode<T>): void;
+    balancePath(node: N): void;
     /**
      * The `balanceLL` function performs a left-left rotation on an AVL tree to balance it.
      * @param A - The parameter A is an AVLTreeNode object.
      */
-    balanceLL(A: AVLTreeNode<T>): void;
+    balanceLL(A: N): void;
     /**
      * The `balanceLR` function performs a left-right rotation to balance an AVL tree.
      * @param A - A is an AVLTreeNode object.
      */
-    balanceLR(A: AVLTreeNode<T>): void;
+    balanceLR(A: N): void;
     /**
      * The `balanceRR` function performs a right-right rotation on an AVL tree to balance it.
      * @param A - The parameter A is an AVLTreeNode object.
      */
-    balanceRR(A: AVLTreeNode<T>): void;
+    balanceRR(A: N): void;
     /**
      * The `balanceRL` function performs a right-left rotation to balance an AVL tree.
      * @param A - A is an AVLTreeNode object.
      */
-    balanceRL(A: AVLTreeNode<T>): void;
+    balanceRL(A: N): void;
 }

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

@@ -40,15 +40,6 @@ var AVLTreeNode = /** @class */ (function (_super) {
     function AVLTreeNode() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    /**
-     * The function overrides the clone method of the AVLTreeNode class to create a new AVLTreeNode object with the same
-     * id, value, and count.
-     * @returns The method is returning a new instance of the AVLTreeNode class with the same id, val, and count values as
-     * the current instance.
-     */
-    AVLTreeNode.prototype.clone = function () {
-        return new AVLTreeNode(this.id, this.val, this.count);
-    };
     return AVLTreeNode;
 }(bst_1.BSTNode));
 exports.AVLTreeNode = AVLTreeNode;
@@ -57,20 +48,21 @@ var AVLTree = /** @class */ (function (_super) {
     function AVLTree() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    AVLTree.prototype.createNode = function (id, val, count) {
-        return new AVLTreeNode(id, val, count);
+    AVLTree.prototype._createNode = function (id, val, count) {
+        var node = new AVLTreeNode(id, val, count);
+        return node;
     };
     /**
      * The function overrides the add method of a Binary Search Tree to insert a node with a given id and value, and then
      * balances the tree.
      * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that we want to add or
      * update in the AVL tree.
-     * @param {T | null} val - The `val` parameter represents the value that you want to assign to the node with the given
-     * `id`. It can be of type `T` (the generic type) or `null`.
+     * @param {N | null} val - The `val` parameter represents the value that you want to assign to the node with the given
+     * `id`. It can be of type `N` (the generic type) or `null`.
      * @param {number} [count] - The `count` parameter is an optional parameter of type `number`. It represents the number
      * of times the value `val` should be inserted into the AVL tree. If the `count` parameter is not provided, it defaults
      * to `1`, indicating that the value should be inserted once.
-     * @returns The method is returning either an AVLTreeNode<T> object or null.
+     * @returns The method is returning either an N object or null.
      */
     AVLTree.prototype.add = function (id, val, count) {
         var inserted = _super.prototype.add.call(this, id, val, count);
@@ -86,7 +78,7 @@ var AVLTree = /** @class */ (function (_super) {
      * @param {boolean} [isUpdateAllLeftSum] - The `isUpdateAllLeftSum` parameter is an optional boolean parameter that
      * determines whether the left sum of all nodes in the AVL tree should be updated after removing a node. If
      * `isUpdateAllLeftSum` is set to `true`, the left sum of all nodes will be recalculated.
-     * @returns The method is returning an array of `AVLTreeDeleted<T>` objects.
+     * @returns The method is returning an array of `AVLTreeDeleted<N>` objects.
      */
     AVLTree.prototype.remove = function (id, isUpdateAllLeftSum) {
         var e_1, _a;
@@ -111,7 +103,7 @@ var AVLTree = /** @class */ (function (_super) {
     /**
      * The balance factor of a given AVL tree node is calculated by subtracting the height of its left subtree from the
      * height of its right subtree.
-     * @param node - The parameter "node" is of type AVLTreeNode<T>, which represents a node in an AVL tree.
+     * @param node - The parameter "node" is of type N, which represents a node in an AVL tree.
      * @returns The balance factor of the given AVL tree node.
      */
     AVLTree.prototype.balanceFactor = function (node) {
@@ -187,7 +179,7 @@ var AVLTree = /** @class */ (function (_super) {
             B.parent = parentOfA;
         if (A === this.root) {
             if (B)
-                this.root = B;
+                this._setRoot(B);
         }
         else {
             if ((parentOfA === null || parentOfA === void 0 ? void 0 : parentOfA.left) === A) {
@@ -232,7 +224,7 @@ var AVLTree = /** @class */ (function (_super) {
         }
         if (A === this.root) {
             if (C)
-                this.root = C;
+                this._setRoot(C);
         }
         else {
             if (parentOfA) {
@@ -271,7 +263,7 @@ var AVLTree = /** @class */ (function (_super) {
         }
         if (A === this.root) {
             if (B)
-                this.root = B;
+                this._setRoot(B);
         }
         else {
             if (parentOfA) {
@@ -315,7 +307,7 @@ var AVLTree = /** @class */ (function (_super) {
         }
         if (A === this.root) {
             if (C)
-                this.root = C;
+                this._setRoot(C);
         }
         else {
             if (parentOfA) {

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

@@ -6,7 +6,6 @@
  * @license MIT License
  */
 export declare class BinaryIndexedTree {
-    private readonly _sumTree;
     /**
      * The constructor initializes an array with a specified length and fills it with zeros.
      * @param {number} n - The parameter `n` represents the size of the array that will be used to store the sum tree. The
@@ -14,6 +13,8 @@ export declare class BinaryIndexedTree {
      * The size of the sum tree array is `n + 1` because
      */
     constructor(n: number);
+    private _sumTree;
+    get sumTree(): number[];
     static lowBit(x: number): number;
     /**
      * The update function updates the values in a binary indexed tree by adding a delta value to the specified index and
@@ -41,4 +42,5 @@ export declare class BinaryIndexedTree {
      * @returns the sum of the elements in the range specified by the start and end indices.
      */
     getRangeSum(start: number, end: number): number;
+    protected _setSumTree(value: number[]): void;
 }