data-structure-typed 1.18.7 → 1.19.0

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 { TreeMultisetNode } from '../binary-tree';
+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/index.d.ts

@@ -1,2 +1,3 @@
 export * from './utils';
 export * from './types';
+export * from './validate-type';

package/dist/utils/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./utils"), exports);
 __exportStar(require("./types"), exports);
+__exportStar(require("./validate-type"), exports);

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

@@ -1 +1,2 @@
 export * from './utils';
+export * from './validate-type';

package/dist/utils/types/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./utils"), exports);
+__exportStar(require("./validate-type"), exports);

package/dist/utils/types/validate-type.d.ts

@@ -0,0 +1,19 @@
+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 RestrictValById = NonNumberNonObjectButDefined | ObjectWithoutId | ObjectWithNonNumberId | ObjectWithNumberId;
+export type DummyAny = string | number | boolean | null | undefined | object | symbol | void | Function | never;

package/dist/utils/types/validate-type.js

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

package/dist/utils/utils.d.ts

@@ -1,5 +1,3 @@
-export declare const uuidV4: () => string;
-export declare const arrayRemove: <T>(array: T[], predicate: (item: T, index: number, array: T[]) => boolean) => T[];
 /**
  * data-structure-typed
  *
@@ -8,6 +6,8 @@ export declare const arrayRemove: <T>(array: T[], predicate: (item: T, index: nu
  * @license MIT License
  */
 import type { Thunk, ToThunkFn, TrlAsyncFn, TrlFn } from './types';
+export declare const uuidV4: () => string;
+export declare const arrayRemove: <T>(array: T[], predicate: (item: T, index: number, array: T[]) => boolean) => T[];
 export declare const THUNK_SYMBOL: unique symbol;
 export declare const isThunk: (fnOrValue: any) => boolean;
 export declare const toThunk: (fn: ToThunkFn) => Thunk;

package/dist/utils/utils.js

@@ -149,65 +149,3 @@ 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);
-//         }
-//     }
-// }

package/dist/utils/validate-type.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { NonNumberNonObjectButDefined, ObjectWithNonNumberId, ObjectWithNumberId, ObjectWithoutId } from './types';
+export declare const nonNumberNonObjectButDefinedSchema: z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodBoolean, z.ZodAny]>>;
+export declare const keyValueObjectSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export declare const objectWithoutIdSchema: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>;
+export declare const keyValueObjectWithIdSchema: z.ZodIntersection<z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodObject<{
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodAny]>;
+}, "strip", z.ZodTypeAny, {
+    id?: any;
+}, {
+    id?: any;
+}>>;
+export declare const objectWithNonNumberIdSchema: z.ZodIntersection<z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodObject<{
+    id: z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodBoolean, z.ZodAny, z.ZodAny, z.ZodUndefined]>>;
+}, "strip", z.ZodTypeAny, {
+    id?: any;
+}, {
+    id?: any;
+}>>;
+export declare const objectWithNumberIdSchema: z.ZodIntersection<z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodObject<{
+    id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+}, {
+    id: number;
+}>>;
+export declare const binaryTreeNodeValWithId: z.ZodUnion<[z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodBoolean, z.ZodAny]>>, z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>, z.ZodIntersection<z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodObject<{
+    id: z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodBoolean, z.ZodAny, z.ZodAny, z.ZodUndefined]>>;
+}, "strip", z.ZodTypeAny, {
+    id?: any;
+}, {
+    id?: any;
+}>>, z.ZodIntersection<z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodObject<{
+    id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+}, {
+    id: number;
+}>>]>;
+export declare function parseBySchema(schema: z.Schema, val: any): boolean;
+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/validate-type.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNumber = exports.isObjectWithNumberId = exports.isObjectWithNonNumberId = exports.isObjectWithoutId = exports.isNonNumberNonObjectButDefined = exports.parseBySchema = exports.binaryTreeNodeValWithId = exports.objectWithNumberIdSchema = exports.objectWithNonNumberIdSchema = exports.keyValueObjectWithIdSchema = exports.objectWithoutIdSchema = exports.keyValueObjectSchema = exports.nonNumberNonObjectButDefinedSchema = void 0;
+var zod_1 = require("zod");
+exports.nonNumberNonObjectButDefinedSchema = zod_1.z.union([zod_1.z.string(),
+    zod_1.z.boolean(), zod_1.z.any()])
+    .nullable();
+exports.keyValueObjectSchema = zod_1.z.record(zod_1.z.unknown());
+exports.objectWithoutIdSchema = exports.keyValueObjectSchema.refine(function (obj) { return !('id' in obj); }, {
+    message: 'Object cannot contain the \'id\' field',
+});
+exports.keyValueObjectWithIdSchema = zod_1.z.record(zod_1.z.any()).and(zod_1.z.object({
+    id: zod_1.z.union([zod_1.z.string(), zod_1.z.number(), zod_1.z.any()])
+}));
+exports.objectWithNonNumberIdSchema = zod_1.z.record(zod_1.z.any()).and(zod_1.z.object({
+    id: zod_1.z
+        .union([zod_1.z.string(), zod_1.z.boolean(), zod_1.z.any(), zod_1.z.any(), zod_1.z.undefined()])
+        .nullable()
+}));
+exports.objectWithNumberIdSchema = zod_1.z.record(zod_1.z.any()).and(zod_1.z.object({
+    id: zod_1.z.number()
+}));
+exports.binaryTreeNodeValWithId = zod_1.z.union([
+    exports.nonNumberNonObjectButDefinedSchema,
+    exports.objectWithoutIdSchema,
+    exports.objectWithNonNumberIdSchema,
+    exports.objectWithNumberIdSchema
+]);
+function parseBySchema(schema, val) {
+    try {
+        schema.parse(val);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+exports.parseBySchema = parseBySchema;
+function isNonNumberNonObjectButDefined(val) {
+    return parseBySchema(exports.nonNumberNonObjectButDefinedSchema, val);
+}
+exports.isNonNumberNonObjectButDefined = isNonNumberNonObjectButDefined;
+function isObjectWithoutId(val) {
+    return parseBySchema(exports.objectWithoutIdSchema, val);
+}
+exports.isObjectWithoutId = isObjectWithoutId;
+function isObjectWithNonNumberId(val) {
+    return parseBySchema(exports.objectWithNonNumberIdSchema, val);
+}
+exports.isObjectWithNonNumberId = isObjectWithNonNumberId;
+function isObjectWithNumberId(val) {
+    return parseBySchema(exports.objectWithNonNumberIdSchema, val);
+}
+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.7",
+  "version": "1.19.0",
   "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,9 @@
     "jest": "^29.6.2",
     "ts-jest": "^29.1.1",
     "typedoc": "^0.24.8",
-    "typescript": "^5.1.5"
+    "typescript": "^4.9.5"
+  },
+  "dependencies": {
+    "zod": "^3.22.2"
   }
 }

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 {
-
-}