data-structure-typed 1.50.6 → 1.50.8

package/dist/mjs/data-structures/binary-tree/bst.js

@@ -1,4 +1,3 @@
-import { BSTVariant, CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { Queue } from '../queue';
 export class BSTNode extends BinaryTreeNode {
@@ -86,7 +85,7 @@ export class BST extends BinaryTree {
     get root() {
         return this._root;
     }
-    _variant = BSTVariant.STANDARD;
+    _variant = 'STANDARD';
     /**
      * The function returns the value of the _variant property.
      * @returns The value of the `_variant` property.
@@ -166,10 +165,10 @@ export class BST extends BinaryTree {
      * @param {K | NODE | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `NODE`, or
      * `undefined`.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
+     * type of iteration to be performed. It has a default value of `'ITERATIVE'`.
      * @returns either a node object (NODE) or undefined.
      */
-    ensureNode(keyOrNodeOrEntry, iterationType = IterationType.ITERATIVE) {
+    ensureNode(keyOrNodeOrEntry, iterationType = 'ITERATIVE') {
         let res;
         if (this.isRealNode(keyOrNodeOrEntry)) {
             res = keyOrNodeOrEntry;
@@ -219,7 +218,7 @@ export class BST extends BinaryTree {
         }
         let current = this.root;
         while (current !== undefined) {
-            if (this._compare(current.key, newNode.key) === CP.eq) {
+            if (this._compare(current.key, newNode.key) === 'EQ') {
                 // if (current !== newNode) {
                 // The key value is the same but the reference is different, update the value of the existing node
                 this._replaceNode(current, newNode);
@@ -230,7 +229,7 @@ export class BST extends BinaryTree {
                 //   return;
                 // }
             }
-            else if (this._compare(current.key, newNode.key) === CP.gt) {
+            else if (this._compare(current.key, newNode.key) === 'GT') {
                 if (current.left === undefined) {
                     current.left = newNode;
                     this._size++;
@@ -339,7 +338,7 @@ export class BST extends BinaryTree {
                 }
             }
         };
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             _dfs(sorted);
         }
         else {
@@ -365,18 +364,18 @@ export class BST extends BinaryTree {
      * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
-    getNodeByKey(key, iterationType = IterationType.ITERATIVE) {
-        if (!this.root)
+    getNodeByKey(key, iterationType = 'ITERATIVE') {
+        if (!this.isRealNode(this.root))
             return undefined;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _dfs = (cur) => {
                 if (cur.key === key)
                     return cur;
-                if (!cur.left && !cur.right)
+                if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
-                if (this._compare(cur.key, key) === CP.gt && cur.left)
+                if (this._compare(cur.key, key) === 'GT' && this.isRealNode(cur.left))
                     return _dfs(cur.left);
-                if (this._compare(cur.key, key) === CP.lt && cur.right)
+                if (this._compare(cur.key, key) === 'LT' && this.isRealNode(cur.right))
                     return _dfs(cur.right);
             };
             return _dfs(this.root);
@@ -385,13 +384,13 @@ export class BST extends BinaryTree {
             const queue = new Queue([this.root]);
             while (queue.size > 0) {
                 const cur = queue.shift();
-                if (cur) {
-                    if (this._compare(cur.key, key) === CP.eq)
+                if (this.isRealNode(cur)) {
+                    if (this._compare(cur.key, key) === 'EQ')
                         return cur;
-                    if (this._compare(cur.key, key) === CP.gt)
-                        cur.left && queue.push(cur.left);
-                    if (this._compare(cur.key, key) === CP.lt)
-                        cur.right && queue.push(cur.right);
+                    if (this._compare(cur.key, key) === 'GT')
+                        this.isRealNode(cur.left) && queue.push(cur.left);
+                    if (this._compare(cur.key, key) === 'LT')
+                        this.isRealNode(cur.right) && queue.push(cur.right);
                 }
             }
         }
@@ -429,7 +428,7 @@ export class BST extends BinaryTree {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _traverse = (cur) => {
                 const callbackResult = callback(cur);
                 if (callbackResult === identifier) {
@@ -437,27 +436,27 @@ export class BST extends BinaryTree {
                     if (onlyOne)
                         return;
                 }
-                if (!cur.left && !cur.right)
+                if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
                 // TODO potential bug
                 if (callback === this._defaultOneParamCallback) {
-                    if (this._compare(cur.key, identifier) === CP.gt)
-                        cur.left && _traverse(cur.left);
-                    if (this._compare(cur.key, identifier) === CP.lt)
-                        cur.right && _traverse(cur.right);
+                    if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === 'GT')
+                        _traverse(cur.left);
+                    if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === 'LT')
+                        _traverse(cur.right);
                 }
                 else {
-                    cur.left && _traverse(cur.left);
-                    cur.right && _traverse(cur.right);
+                    this.isRealNode(cur.left) && _traverse(cur.left);
+                    this.isRealNode(cur.right) && _traverse(cur.right);
                 }
             };
             _traverse(beginRoot);
         }
         else {
-            const queue = new Queue([beginRoot]);
-            while (queue.size > 0) {
-                const cur = queue.shift();
-                if (cur) {
+            const stack = [beginRoot];
+            while (stack.length > 0) {
+                const cur = stack.pop();
+                if (this.isRealNode(cur)) {
                     const callbackResult = callback(cur);
                     if (callbackResult === identifier) {
                         ans.push(cur);
@@ -466,14 +465,20 @@ export class BST extends BinaryTree {
                     }
                     // TODO potential bug
                     if (callback === this._defaultOneParamCallback) {
-                        if (this._compare(cur.key, identifier) === CP.gt)
-                            cur.left && queue.push(cur.left);
-                        if (this._compare(cur.key, identifier) === CP.lt)
-                            cur.right && queue.push(cur.right);
+                        if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === 'LT')
+                            stack.push(cur.right);
+                        if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === 'GT')
+                            stack.push(cur.left);
+                        // if (this.isRealNode(cur.right) && this._lt(cur.key, identifier as K)) stack.push(cur.right);
+                        // if (this.isRealNode(cur.left) && this._gt(cur.key, identifier as K)) stack.push(cur.left);
+                        // // @ts-ignore
+                        // if (this.isRealNode(cur.right) && cur.key > identifier) stack.push(cur.right);
+                        // // @ts-ignore
+                        // if (this.isRealNode(cur.left) && cur.key < identifier) stack.push(cur.left);
                     }
                     else {
-                        cur.left && queue.push(cur.left);
-                        cur.right && queue.push(cur.right);
+                        this.isRealNode(cur.right) && stack.push(cur.right);
+                        this.isRealNode(cur.left) && stack.push(cur.left);
                     }
                 }
             }
@@ -503,7 +508,7 @@ export class BST extends BinaryTree {
      * following values:
      * @returns The method is returning an array of the return type of the callback function.
      */
-    dfs(callback = this._defaultOneParamCallback, pattern = 'in', beginRoot = this.root, iterationType = IterationType.ITERATIVE) {
+    dfs(callback = this._defaultOneParamCallback, pattern = 'in', beginRoot = this.root, iterationType = 'ITERATIVE') {
         return super.dfs(callback, pattern, beginRoot, iterationType, false);
     }
     /**
@@ -576,7 +581,7 @@ export class BST extends BinaryTree {
         let current = this.ensureNode(beginRoot);
         if (!current)
             return undefined;
-        if (this._variant === BSTVariant.STANDARD) {
+        if (this._variant === 'STANDARD') {
             // For BSTVariant.MIN, find the rightmost node
             while (current.right !== undefined) {
                 current = current.right;
@@ -615,7 +620,7 @@ export class BST extends BinaryTree {
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = CP.lt, targetNode = this.root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = 'LT', targetNode = this.root, iterationType = this.iterationType) {
         targetNode = this.ensureNode(targetNode);
         const ans = [];
         if (!targetNode)
@@ -623,7 +628,7 @@ export class BST extends BinaryTree {
         if (!this.root)
             return ans;
         const targetKey = targetNode.key;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _traverse = (cur) => {
                 const compared = this._compare(cur.key, targetKey);
                 if (compared === lesserOrGreater)
@@ -673,7 +678,7 @@ export class BST extends BinaryTree {
         this.clear();
         if (sorted.length < 1)
             return false;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
@@ -730,7 +735,7 @@ export class BST extends BinaryTree {
         if (!this.root)
             return true;
         let balanced = true;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _height = (cur) => {
                 if (!cur)
                     return 0;
@@ -787,13 +792,29 @@ export class BST extends BinaryTree {
      * is greater than, less than, or equal to the second value.
      * @param {K} a - The parameter "a" is of type K.
      * @param {K} b - The parameter "b" in the above code represents a K.
-     * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater
-     * than), CP.lt (less than), or CP.eq (equal).
+     * @returns a value of type CP (ComparisonResult). The possible return values are 'GT' (greater
+     * than), 'LT' (less than), or 'EQ' (equal).
      */
     _compare(a, b) {
         const extractedA = this.extractor(a);
         const extractedB = this.extractor(b);
-        const compared = this.variant === BSTVariant.STANDARD ? extractedA - extractedB : extractedB - extractedA;
-        return compared > 0 ? CP.gt : compared < 0 ? CP.lt : CP.eq;
+        const compared = this.variant === 'STANDARD' ? extractedA - extractedB : extractedB - extractedA;
+        return compared > 0 ? 'GT' : compared < 0 ? 'LT' : 'EQ';
+    }
+    _lt(a, b) {
+        const extractedA = this.extractor(a);
+        const extractedB = this.extractor(b);
+        // return this.variant === BSTVariant.STANDARD ? extractedA < extractedB : extractedA > extractedB;
+        return this.variant === 'STANDARD' ? extractedA < extractedB : extractedA > extractedB;
+        // return extractedA < extractedB;
+        // return a < b;
+    }
+    _gt(a, b) {
+        const extractedA = this.extractor(a);
+        const extractedB = this.extractor(b);
+        // return this.variant === BSTVariant.STANDARD  ? extractedA > extractedB : extractedA < extractedB;
+        return this.variant === 'STANDARD' ? extractedA > extractedB : extractedA < extractedB;
+        // return extractedA > extractedB;
+        // return a > b;
     }
 }

package/dist/mjs/data-structures/binary-tree/rb-tree.d.ts

@@ -1,5 +1,5 @@
 import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
-import { RBTNColor } from '../../types';
+import { CRUD, RBTNColor } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
@@ -51,12 +51,6 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * @returns The root node of the tree structure, or undefined if there is no root node.
      */
     get root(): NODE | undefined;
-    protected _size: number;
-    /**
-     * The function returns the size of an object.
-     * @returns The size of the object, which is a number.
-     */
-    get size(): number;
     /**
      * The function creates a new Red-Black Tree node with the specified key, value, and color.
      * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
@@ -236,7 +230,7 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * node in the tree.
      * @returns {'inserted' | 'updated'} - The result of the insertion.
      */
-    protected _insert(node: NODE): 'inserted' | 'updated';
+    protected _insert(node: NODE): CRUD;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

package/dist/mjs/data-structures/binary-tree/rb-tree.js

@@ -66,14 +66,6 @@ export class RedBlackTree extends BST {
     get root() {
         return this._root;
     }
-    _size = 0;
-    /**
-     * The function returns the size of an object.
-     * @returns The size of the object, which is a number.
-     */
-    get size() {
-        return this._size;
-    }
     /**
      * The function creates a new Red-Black Tree node with the specified key, value, and color.
      * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
@@ -171,7 +163,7 @@ export class RedBlackTree extends BST {
      * @returns a boolean value.
      */
     isRealNode(node) {
-        if (node === this._SENTINEL || node === undefined)
+        if (node === this.SENTINEL || node === undefined)
             return false;
         return node instanceof RedBlackTreeNode;
     }
@@ -201,9 +193,7 @@ export class RedBlackTree extends BST {
      * @returns The method is returning a value of type `NODE | null | undefined`.
      */
     getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
-        if (identifier instanceof RedBlackTreeNode)
-            callback = (node => node);
-        beginRoot = this.ensureNode(beginRoot);
+        // if ((identifier as any) instanceof RedBlackTreeNode) callback = (node => node) as C;
         return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
     }
     /**
@@ -218,8 +208,8 @@ export class RedBlackTree extends BST {
      * size counter to zero.
      */
     clear() {
+        super.clear();
         this._root = this.SENTINEL;
-        this._size = 0;
     }
     /**
      * Time Complexity: O(log n)
@@ -243,7 +233,7 @@ export class RedBlackTree extends BST {
         if (!this.isRealNode(newNode))
             return false;
         const insertStatus = this._insert(newNode);
-        if (insertStatus === 'inserted') {
+        if (insertStatus === 'CREATED') {
             // Ensure the root is black
             if (this.isRealNode(this._root)) {
                 this._root.color = RBTNColor.BLACK;
@@ -255,7 +245,7 @@ export class RedBlackTree extends BST {
             return true;
         }
         else
-            return insertStatus === 'updated';
+            return insertStatus === 'UPDATED';
     }
     /**
      * Time Complexity: O(log n)
@@ -387,7 +377,7 @@ export class RedBlackTree extends BST {
             }
             else {
                 this._replaceNode(current, node);
-                return 'updated';
+                return 'UPDATED';
             }
         }
         node.parent = parent;
@@ -404,7 +394,7 @@ export class RedBlackTree extends BST {
         node.right = this.SENTINEL;
         node.color = RBTNColor.RED;
         this._insertFixup(node);
-        return 'inserted';
+        return 'CREATED';
     }
     /**
      * Time Complexity: O(1)

package/dist/mjs/data-structures/binary-tree/tree-multi-map.d.ts

@@ -6,7 +6,6 @@
  * @license MIT License
  */
 import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
-import { IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
 export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>> extends RedBlackTreeNode<K, V, NODE> {
@@ -164,7 +163,7 @@ export declare class TreeMultiMap<K = any, V = any, NODE extends TreeMultiMapNod
      * values:
      * @returns a boolean value.
      */
-    perfectlyBalance(iterationType?: IterationType): boolean;
+    perfectlyBalance(iterationType?: import("../../types").IterationType): boolean;
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)

package/dist/mjs/data-structures/binary-tree/tree-multi-map.js

@@ -1,4 +1,4 @@
-import { IterationType, RBTNColor } from '../../types';
+import { RBTNColor } from '../../types';
 import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
 export class TreeMultiMapNode extends RedBlackTreeNode {
     /**
@@ -311,7 +311,7 @@ export class TreeMultiMap extends RedBlackTree {
         if (sorted.length < 1)
             return false;
         this.clear();
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;

package/dist/mjs/types/common.d.ts

@@ -1,31 +1,13 @@
-export declare enum BSTVariant {
-    STANDARD = "STANDARD",
-    INVERSE = "INVERSE"
-}
-export declare enum CP {
-    lt = "lt",
-    eq = "eq",
-    gt = "gt"
-}
+export type BSTVariant = 'STANDARD' | 'INVERSE';
+export type CP = 'LT' | 'EQ' | 'GT';
 /**
  * Enum representing different loop types.
  *
  * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
  * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
  */
-export declare enum IterationType {
-    ITERATIVE = "ITERATIVE",
-    RECURSIVE = "RECURSIVE"
-}
-export declare enum FamilyPosition {
-    ROOT = "ROOT",
-    LEFT = "LEFT",
-    RIGHT = "RIGHT",
-    ROOT_LEFT = "ROOT_LEFT",
-    ROOT_RIGHT = "ROOT_RIGHT",
-    ISOLATED = "ISOLATED",
-    MAL_NODE = "MAL_NODE"
-}
+export type IterationType = 'ITERATIVE' | 'RECURSIVE';
+export type FamilyPosition = 'ROOT' | 'LEFT' | 'RIGHT' | 'ROOT_LEFT' | 'ROOT_RIGHT' | 'ISOLATED' | 'MAL_NODE';
 export type Comparator<K> = (a: K, b: K) => number;
 export type DFSOrderPattern = 'pre' | 'in' | 'post';
 export type NodeDisplayLayout = [string[], number, number, number];
@@ -52,3 +34,4 @@ export type BinaryTreeDeleteResult<N> = {
     deleted: N | null | undefined;
     needBalanced: N | null | undefined;
 };
+export type CRUD = 'CREATED' | 'READ' | 'UPDATED' | 'DELETED';

package/dist/mjs/types/common.js

@@ -1,32 +1 @@
-export var BSTVariant;
-(function (BSTVariant) {
-    BSTVariant["STANDARD"] = "STANDARD";
-    BSTVariant["INVERSE"] = "INVERSE";
-})(BSTVariant || (BSTVariant = {}));
-export var CP;
-(function (CP) {
-    CP["lt"] = "lt";
-    CP["eq"] = "eq";
-    CP["gt"] = "gt";
-})(CP || (CP = {}));
-/**
- * Enum representing different loop types.
- *
- * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
- * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
- */
-export var IterationType;
-(function (IterationType) {
-    IterationType["ITERATIVE"] = "ITERATIVE";
-    IterationType["RECURSIVE"] = "RECURSIVE";
-})(IterationType || (IterationType = {}));
-export var FamilyPosition;
-(function (FamilyPosition) {
-    FamilyPosition["ROOT"] = "ROOT";
-    FamilyPosition["LEFT"] = "LEFT";
-    FamilyPosition["RIGHT"] = "RIGHT";
-    FamilyPosition["ROOT_LEFT"] = "ROOT_LEFT";
-    FamilyPosition["ROOT_RIGHT"] = "ROOT_RIGHT";
-    FamilyPosition["ISOLATED"] = "ISOLATED";
-    FamilyPosition["MAL_NODE"] = "MAL_NODE";
-})(FamilyPosition || (FamilyPosition = {}));
+export {};