data-structure-typed 1.18.6 → 1.18.8

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

@@ -1,4 +1,4 @@
 import { BinaryTreeNode } from '../binary-tree';
 import { AbstractBinaryTreeOptions } from './abstract-binary-tree';
-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>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type BinaryTreeNodeNested<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>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BinaryTreeOptions = AbstractBinaryTreeOptions & {};

package/dist/data-structures/types/bst.d.ts

@@ -2,7 +2,7 @@ import { BSTNode } from '../binary-tree';
 import type { BinaryTreeOptions } from './binary-tree';
 import { BinaryTreeNodeId } from './abstract-binary-tree';
 export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
-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>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type BSTNodeNested<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>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BSTOptions = BinaryTreeOptions & {
     comparator?: BSTComparator;
 };

package/dist/data-structures/types/bst.js

@@ -6,4 +6,4 @@ var CP;
     CP["lt"] = "lt";
     CP["eq"] = "eq";
     CP["gt"] = "gt";
-})(CP || (exports.CP = CP = {}));
+})(CP = exports.CP || (exports.CP = {}));

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

@@ -6,4 +6,4 @@ var TopologicalProperty;
     TopologicalProperty["VAL"] = "VAL";
     TopologicalProperty["NODE"] = "NODE";
     TopologicalProperty["ID"] = "ID";
-})(TopologicalProperty || (exports.TopologicalProperty = TopologicalProperty = {}));
+})(TopologicalProperty = exports.TopologicalProperty || (exports.TopologicalProperty = {}));

package/dist/data-structures/types/helpers.d.ts

@@ -1,8 +1 @@
-export type IdObject = {
-    id: number;
-} & {
-    [key: string]: any;
-};
-export type KeyValObject = {
-    [key: string]: any;
-};
+export {};

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

@@ -1,6 +1,8 @@
 import { BinaryTreeOptions } from './binary-tree';
+import { RBTreeNode } from '../binary-tree';
 export declare enum RBColor {
     RED = "RED",
     BLACK = "BLACK"
 }
+export type RBTreeNodeNested<T> = RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type RBTreeOptions = BinaryTreeOptions & {};

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

@@ -5,4 +5,4 @@ var RBColor;
 (function (RBColor) {
     RBColor["RED"] = "RED";
     RBColor["BLACK"] = "BLACK";
-})(RBColor || (exports.RBColor = RBColor = {}));
+})(RBColor = exports.RBColor || (exports.RBColor = {}));

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

@@ -1,6 +1,6 @@
-import { BSTOptions } from './bst';
 import { TreeMultiSetNode } from '../binary-tree';
-export type RecursiveTreeMultiSetNode<T> = TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type TreeMultiSetOptions = Omit<BSTOptions, 'isDuplicatedVal'> & {
-    isDuplicatedVal: true;
+import { AVLTreeOptions } from './avl-tree';
+export type TreeMultiSetNodeNested<T> = TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type TreeMultiSetOptions = Omit<AVLTreeOptions, 'isMergeDuplicatedVal'> & {
+    isMergeDuplicatedVal: true;
 };

package/dist/utils/types/utils.d.ts

@@ -5,3 +5,21 @@ export type Thunk = () => ReturnType<ToThunkFn> & {
 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>>;
+export type KeyValueObject = {
+    [key: string]: any;
+};
+export type KeyValueObjectWithId = {
+    [key: string]: any;
+    id: string | number | symbol;
+};
+export type NonNumberNonObjectButDefined = string | boolean | symbol | null;
+export type ObjectWithoutId = Omit<KeyValueObject, 'id'>;
+export type ObjectWithNonNumberId = {
+    [key: string]: any;
+    id: string | boolean | symbol | null | object | undefined;
+};
+export type ObjectWithNumberId = {
+    [key: string]: any;
+    id: number;
+};
+export type DummyAny = string | number | boolean | null | undefined | object | symbol | void | Function | never;

package/dist/utils/utils.d.ts

@@ -7,7 +7,7 @@ export declare const arrayRemove: <T>(array: T[], predicate: (item: T, index: nu
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { Thunk, ToThunkFn, TrlAsyncFn, TrlFn } from './types';
+import type { NonNumberNonObjectButDefined, ObjectWithNonNumberId, ObjectWithNumberId, ObjectWithoutId, Thunk, ToThunkFn, TrlAsyncFn, TrlFn } from './types';
 export declare const THUNK_SYMBOL: unique symbol;
 export declare const isThunk: (fnOrValue: any) => boolean;
 export declare const toThunk: (fn: ToThunkFn) => Thunk;
@@ -17,3 +17,8 @@ export declare const trampoline: (fn: TrlFn) => ((...args: [...Parameters<TrlFn>
 export declare const trampolineAsync: (fn: TrlAsyncFn) => ((...args: [...Parameters<TrlAsyncFn>]) => Promise<any>) & {
     cont: (...args: [...Parameters<TrlAsyncFn>]) => Thunk;
 };
+export declare function isNonNumberNonObjectButDefined(val: any): val is NonNumberNonObjectButDefined;
+export declare function isObjectWithoutId(val: any): val is ObjectWithoutId;
+export declare function isObjectWithNonNumberId(val: any): val is ObjectWithNonNumberId;
+export declare function isObjectWithNumberId(val: any): val is ObjectWithNumberId;
+export declare function isNumber(val: any): val is number;

package/dist/utils/utils.js

@@ -61,7 +61,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.trampolineAsync = exports.trampoline = exports.toThunk = exports.isThunk = exports.THUNK_SYMBOL = exports.arrayRemove = exports.uuidV4 = void 0;
+exports.isNumber = exports.isObjectWithNumberId = exports.isObjectWithNonNumberId = exports.isObjectWithoutId = exports.isNonNumberNonObjectButDefined = exports.trampolineAsync = exports.trampoline = exports.toThunk = exports.isThunk = exports.THUNK_SYMBOL = exports.arrayRemove = exports.uuidV4 = void 0;
 var uuidV4 = function () {
     return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
         var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
@@ -149,3 +149,85 @@ var trampolineAsync = function (fn) {
     }, { cont: cont });
 };
 exports.trampolineAsync = trampolineAsync;
+// export class AutoPruneMap<K, V> extends Map<K, V> {
+//
+//     private _proxySet: Set<V>;
+//     get proxySet(): Set<V> {
+//         return this._proxySet;
+//     }
+//
+//     set proxySet(value: Set<V>) {
+//         this._proxySet = value;
+//     }
+//
+//     private _isEmptyArrayAllowed: boolean;
+//
+//     get isEmptyArrayAllowed(): boolean {
+//         return this._isEmptyArrayAllowed;
+//     }
+//
+//     set isEmptyArrayAllowed(value: boolean) {
+//         this._isEmptyArrayAllowed = value;
+//     }
+//
+//     constructor(isEmptyArrayAllowed: boolean = false) {
+//         super();
+//         this._isEmptyArrayAllowed = isEmptyArrayAllowed;
+//         this._proxySet = new Set<V>();
+//     }
+//
+//     set(key: K, value: V): this {
+//         if (Array.isArray(value) && !this.proxySet.has(value)) {
+//             if(!this.isEmptyArrayAllowed && value.length === 0) return this;
+//             value = this.createArrayProxy(value, key);
+//             if (!this.proxySet.has(value)) this.proxySet.add(value);
+//         }
+//         super.set(key, value);
+//         return this;
+//     }
+//
+//     private createArrayProxy(array: V & any[], key: K) {
+//         const that = this;
+//         const proxyHandler: ProxyHandler<V & any[]> = {
+//             set(target: any, property: PropertyKey, value: any): boolean {
+//                 const result = Reflect.set(target, property, value);
+//                 that.checkAndDeleteEmptyArray(key);
+//                 return result;
+//             },
+//             deleteProperty(target: any, property: PropertyKey): boolean {
+//                 const result = Reflect.deleteProperty(target, property);
+//                 that.checkAndDeleteEmptyArray(key);
+//                 return result;
+//             },
+//         }
+//         return new Proxy(array, proxyHandler);
+//     }
+//
+//     private checkAndDeleteEmptyArray(key: K): void {
+//         const value = this.get(key);
+//
+//         if (Array.isArray(value) && value.length === 0) {
+//             super.delete(key);
+//         }
+//     }
+// }
+function isNonNumberNonObjectButDefined(val) {
+    return typeof val !== 'number' && typeof val !== 'object' && val !== undefined;
+}
+exports.isNonNumberNonObjectButDefined = isNonNumberNonObjectButDefined;
+function isObjectWithoutId(val) {
+    return typeof val === 'object' && !('id' in val);
+}
+exports.isObjectWithoutId = isObjectWithoutId;
+function isObjectWithNonNumberId(val) {
+    return typeof val === 'object' && 'id' in val && typeof val.id !== 'number';
+}
+exports.isObjectWithNonNumberId = isObjectWithNonNumberId;
+function isObjectWithNumberId(val) {
+    return typeof val === 'object' && 'id' in val && typeof val.id === 'number';
+}
+exports.isObjectWithNumberId = isObjectWithNumberId;
+function isNumber(val) {
+    return typeof val === 'number';
+}
+exports.isNumber = isNumber;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.18.6",
+  "version": "1.18.8",
   "description": "Explore our comprehensive Javascript Data Structure / TypeScript Data Structure Library, meticulously crafted to empower developers with a versatile set of essential data structures. Our library includes a wide range of data structures, such as Binary Tree, AVL Tree, Binary Search Tree (BST), Tree Multiset, Segment Tree, Binary Indexed Tree, Graph, Directed Graph, Undirected Graph, Singly Linked List, Hash, CoordinateSet, CoordinateMap, Heap, Doubly Linked List, Priority Queue, Max Priority Queue, Min Priority Queue, Queue, ObjectDeque, ArrayDeque, Stack, and Trie. Each data structure is thoughtfully designed and implemented using TypeScript to provide efficient, reliable, and easy-to-use solutions for your programming needs. Whether you're optimizing algorithms, managing data, or enhancing performance, our TypeScript Data Structure Library is your go-to resource. Elevate your coding experience with these fundamental building blocks for software development.",
   "main": "dist/index.js",
   "scripts": {
@@ -62,6 +62,6 @@
     "jest": "^29.6.2",
     "ts-jest": "^29.1.1",
     "typedoc": "^0.24.8",
-    "typescript": "^5.1.6"
+    "typescript": "^4.9.5"
   }
 }

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

@@ -1,3 +0,0 @@
-export class AaTree {
-
-}

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

@@ -1,288 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import {BST, BSTNode} from './bst';
-import type {AVLTreeDeleted, BinaryTreeNodeId, RecursiveAVLTreeNode} from '../types';
-import {IBinaryTreeNode} from '../interfaces';
-
-
-export class AVLTreeNode<T, FAMILY extends AVLTreeNode<T, FAMILY > = RecursiveAVLTreeNode<T>> extends BSTNode<T, FAMILY> implements IBinaryTreeNode<T, FAMILY> {
-
-}
-
-export class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode<number>> extends BST<N> {
-
-    override _createNode(id: BinaryTreeNodeId, val: N['val'], count?: number): N {
-        const node = new AVLTreeNode<N['val'], N>(id, val, count);
-        return node as 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 {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 N object or null.
-     */
-    override add(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null {
-        const inserted = super.add(id, val, count);
-        if (inserted) this.balancePath(inserted);
-        return inserted;
-    }
-
-    /**
-     * The function overrides the remove method of the Binary Search Tree class, performs the removal operation, and
-     * then balances the tree if necessary.
-     * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node that needs to be
-     * removed from the AVL tree.
-     * @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<N>` objects.
-     */
-    override remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): AVLTreeDeleted<N>[] {
-        const deletedResults = super.remove(id, isUpdateAllLeftSum);
-        for (const {needBalanced} of deletedResults) {
-            if (needBalanced) {
-                this.balancePath(needBalanced);
-            }
-        }
-        return deletedResults;
-    }
-
-    /**
-     * 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 N, which represents a node in an AVL tree.
-     * @returns The balance factor of the given AVL tree node.
-     */
-    balanceFactor(node: N): number {
-        if (!node.right) // node has no right subtree
-            return -node.height;
-        else if (!node.left) // node has no left subtree
-            return +node.height;
-        else
-            return node.right.height - node.left.height;
-    }
-
-    /**
-     * 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: N): void {
-        if (!node.left && !node.right) // node is a leaf
-            node.height = 0;
-        else if (!node.left) {
-            // node has no left subtree
-            const rightHeight = node.right ? node.right.height : 0;
-            node.height = 1 + rightHeight;
-        } else if (!node.right) // node has no right subtree
-            node.height = 1 + node.left.height;
-        else
-            node.height = 1 + Math.max(node.right.height, node.left.height);
-    }
-
-    /**
-     * 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: N): void {
-        const path = this.getPathToRoot(node);
-        for (let i = path.length - 1; i >= 0; i--) {
-            const A = path[i];
-            this.updateHeight(A);
-            switch (this.balanceFactor(A)) {
-                case -2:
-                    if (A && A.left) {
-                        if (this.balanceFactor(A.left) <= 0) {
-                            this.balanceLL(A); // Perform LL rotation
-                        } else {
-                            this.balanceLR(A); // Perform LR rotation
-                        }
-                    }
-                    break;
-                case +2:
-                    if (A && A.right) {
-                        if (this.balanceFactor(A.right) >= 0) {
-                            this.balanceRR(A); // Perform RR rotation
-                        } else {
-                            this.balanceRL(A); // Perform RL rotation
-                        }
-                    }
-            }
-        }
-    }
-
-    /**
-     * 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: N): void {
-        const parentOfA = A.parent;
-        const B = A.left; // A is left-heavy and B is left-heavy
-        A.parent = B;
-        if (B && B.right) {
-            B.right.parent = A;
-        }
-        if (B) B.parent = parentOfA;
-        if (A === this.root) {
-            if (B) this._setRoot(B);
-        } else {
-            if (parentOfA?.left === A) {
-                parentOfA.left = B;
-            } else {
-                if (parentOfA) parentOfA.right = B;
-            }
-        }
-
-        if (B) {
-            A.left = B.right; // Make T2 the left subtree of A
-            B.right = A; // Make A the left child of B
-        }
-        this.updateHeight(A);
-        if (B) this.updateHeight(B);
-    }
-
-    /**
-     * The `balanceLR` function performs a left-right rotation to balance an AVL tree.
-     * @param A - A is an AVLTreeNode object.
-     */
-    balanceLR(A: N): void {
-        const parentOfA = A.parent;
-        const B = A.left; // A is left-heavy
-        let C = null;
-        if (B) {
-            C = B.right;// B is right-heavy
-        }
-        if (A) A.parent = C;
-        if (B) B.parent = C;
-
-        if (C) {
-            if (C.left) {
-                C.left.parent = B;
-            }
-            if (C.right) {
-                C.right.parent = A;
-            }
-            C.parent = parentOfA;
-        }
-
-        if (A === this.root) {
-            if (C) this._setRoot(C);
-        } else {
-            if (parentOfA) {
-                if (parentOfA.left === A) {
-                    parentOfA.left = C;
-                } else {
-                    parentOfA.right = C;
-                }
-            }
-        }
-
-        if (C) {
-            A.left = C.right; // Make T3 the left subtree of A
-            if (B) B.right = C.left; // Make T2 the right subtree of B
-            C.left = B;
-            C.right = A;
-        }
-
-        this.updateHeight(A); // Adjust heights
-        B && this.updateHeight(B);
-        C && this.updateHeight(C);
-    }
-
-    /**
-     * 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: N): void {
-        const parentOfA = A.parent;
-        const B = A.right; // A is right-heavy and B is right-heavy
-        A.parent = B;
-        if (B) {
-            if (B.left) {
-                B.left.parent = A;
-            }
-            B.parent = parentOfA;
-        }
-
-        if (A === this.root) {
-            if (B) this._setRoot(B);
-        } else {
-            if (parentOfA) {
-                if (parentOfA.left === A) {
-                    parentOfA.left = B;
-                } else {
-                    parentOfA.right = B;
-                }
-            }
-        }
-
-        if (B) {
-            A.right = B.left; // Make T2 the right subtree of A
-            B.left = A;
-        }
-        this.updateHeight(A);
-        B && this.updateHeight(B);
-    }
-
-    /**
-     * The `balanceRL` function performs a right-left rotation to balance an AVL tree.
-     * @param A - A is an AVLTreeNode object.
-     */
-    balanceRL(A: N): void {
-        const parentOfA = A.parent;
-        const B = A.right; // A is right-heavy
-        let C = null;
-        if (B) {
-            C = B.left; // B is left-heavy
-        }
-
-        A.parent = C;
-        if (B) B.parent = C;
-
-        if (C) {
-            if (C.left) {
-                C.left.parent = A;
-            }
-            if (C.right) {
-                C.right.parent = B;
-            }
-            C.parent = parentOfA;
-        }
-
-
-        if (A === this.root) {
-            if (C) this._setRoot(C);
-        } else {
-            if (parentOfA) {
-                if (parentOfA.left === A) {
-                    parentOfA.left = C;
-                } else {
-                    parentOfA.right = C;
-                }
-            }
-        }
-
-        if (C) A.right = C.left; // Make T2 the right subtree of A
-        if (B && C) B.left = C.right; // Make T3 the left subtree of B
-        if (C) C.left = A;
-        if (C) C.right = B;
-
-        this.updateHeight(A); // Adjust heights
-        B && this.updateHeight(B);
-        C && this.updateHeight(C);
-    }
-}
-
-

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

@@ -1,3 +0,0 @@
-export class BTree {
-
-}

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

@@ -1,78 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export class BinaryIndexedTree {
-
-    /**
-     * 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
-     * sum tree is a binary tree data structure used to efficiently calculate the sum of a range of elements in an array.
-     * The size of the sum tree array is `n + 1` because
-     */
-    constructor(n: number) {
-        this._sumTree = new Array<number>(n + 1).fill(0);
-    }
-
-    private _sumTree: number[];
-
-    get sumTree(): number[] {
-        return this._sumTree;
-    }
-
-    static lowBit(x: number) {
-        return x & (-x);
-    }
-
-    /**
-     * The update function updates the values in a binary indexed tree by adding a delta value to the specified index and
-     * its ancestors.
-     * @param {number} i - The parameter `i` represents the index of the element in the `_sumTree` array that needs to be
-     * updated.
-     * @param {number} delta - The "delta" parameter represents the change in value that needs to be added to the element
-     * at index "i" in the "_sumTree" array.
-     */
-    update(i: number, delta: number) {
-        while (i < this._sumTree.length) {
-            this._sumTree[i] += delta;
-            i += BinaryIndexedTree.lowBit(i);
-        }
-    }
-
-    /**
-     * The function calculates the prefix sum of an array using a binary indexed tree.
-     * @param {number} i - The parameter "i" in the function "getPrefixSum" represents the index of the element in the
-     * array for which we want to calculate the prefix sum.
-     * @returns The function `getPrefixSum` returns the prefix sum of the elements in the binary indexed tree up to index
-     * `i`.
-     */
-    getPrefixSum(i: number) {
-        let sum = 0;
-        while (i > 0) {
-            sum += this._sumTree[i];
-            i -= BinaryIndexedTree.lowBit(i);
-        }
-        return sum;
-    }
-
-    /**
-     * The function `getRangeSum` calculates the sum of a range of numbers in an array.
-     * @param {number} start - The start parameter is the starting index of the range for which we want to calculate the
-     * sum.
-     * @param {number} end - The "end" parameter represents the ending index of the range for which we want to calculate
-     * the sum.
-     * @returns the sum of the elements in the range specified by the start and end indices.
-     */
-    getRangeSum(start: number, end: number): number {
-        if (!(0 <= start && start <= end && end <= this._sumTree.length))
-            throw 'Index out of bounds';
-        return this.getPrefixSum(end) - this.getPrefixSum(start);
-    }
-
-    protected _setSumTree(value: number[]) {
-        this._sumTree = value;
-    }
-}