heap-typed 1.50.6 → 1.50.8

package/src/data-structures/binary-tree/bst.ts

@@ -126,7 +126,7 @@ export class BST<
     return this._root;
   }
 
-  protected _variant = BSTVariant.STANDARD;
+  protected _variant: BSTVariant = 'STANDARD';
 
   /**
    * The function returns the value of the _variant property.
@@ -207,13 +207,10 @@ export class BST<
    * @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.
    */
-  override ensureNode(
-    keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
-    iterationType = IterationType.ITERATIVE
-  ): NODE | undefined {
+  override ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, iterationType = 'ITERATIVE'): NODE | undefined {
     let res: NODE | undefined;
     if (this.isRealNode(keyOrNodeOrEntry)) {
       res = keyOrNodeOrEntry;
@@ -263,7 +260,7 @@ export class BST<
 
     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);
@@ -275,7 +272,7 @@ export class BST<
 
         //   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++;
@@ -397,7 +394,7 @@ export class BST<
       }
     };
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       _dfs(sorted);
     } else {
       _iterate();
@@ -425,15 +422,15 @@ export class BST<
    * @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`.
    */
-  override getNodeByKey(key: K, iterationType = IterationType.ITERATIVE): NODE | undefined {
-    if (!this.root) return undefined;
-    if (iterationType === IterationType.RECURSIVE) {
+  override getNodeByKey(key: K, iterationType = 'ITERATIVE'): NODE | undefined {
+    if (!this.isRealNode(this.root)) return undefined;
+    if (iterationType === 'RECURSIVE') {
       const _dfs = (cur: NODE): NODE | undefined => {
         if (cur.key === key) return cur;
-        if (!cur.left && !cur.right) return;
+        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
 
-        if (this._compare(cur.key, key) === CP.gt && cur.left) return _dfs(cur.left);
-        if (this._compare(cur.key, key) === CP.lt && cur.right) return _dfs(cur.right);
+        if (this._compare(cur.key, key) === 'GT' && this.isRealNode(cur.left)) return _dfs(cur.left);
+        if (this._compare(cur.key, key) === 'LT' && this.isRealNode(cur.right)) return _dfs(cur.right);
       };
 
       return _dfs(this.root);
@@ -441,10 +438,10 @@ export class BST<
       const queue = new Queue<NODE>([this.root]);
       while (queue.size > 0) {
         const cur = queue.shift();
-        if (cur) {
-          if (this._compare(cur.key, key) === CP.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.isRealNode(cur)) {
+          if (this._compare(cur.key, key) === 'EQ') return cur;
+          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);
         }
       }
     }
@@ -489,7 +486,7 @@ export class BST<
     if (!beginRoot) return [];
     const ans: NODE[] = [];
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _traverse = (cur: NODE) => {
         const callbackResult = callback(cur);
         if (callbackResult === identifier) {
@@ -497,23 +494,23 @@ export class BST<
           if (onlyOne) return;
         }
 
-        if (!cur.left && !cur.right) return;
+        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
         // TODO potential bug
         if (callback === this._defaultOneParamCallback) {
-          if (this._compare(cur.key, identifier as K) === CP.gt) cur.left && _traverse(cur.left);
-          if (this._compare(cur.key, identifier as K) === CP.lt) cur.right && _traverse(cur.right);
+          if (this.isRealNode(cur.left) && this._compare(cur.key, identifier as K) === 'GT') _traverse(cur.left);
+          if (this.isRealNode(cur.right) && this._compare(cur.key, identifier as K) === '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<NODE>([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);
@@ -521,11 +518,19 @@ export class BST<
           }
           // TODO potential bug
           if (callback === this._defaultOneParamCallback) {
-            if (this._compare(cur.key, identifier as K) === CP.gt) cur.left && queue.push(cur.left);
-            if (this._compare(cur.key, identifier as K) === CP.lt) cur.right && queue.push(cur.right);
+            if (this.isRealNode(cur.right) && this._compare(cur.key, identifier as K) === 'LT') stack.push(cur.right);
+            if (this.isRealNode(cur.left) && this._compare(cur.key, identifier as K) === '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);
           }
         }
       }
@@ -562,7 +567,7 @@ export class BST<
     callback: C = this._defaultOneParamCallback as C,
     pattern: DFSOrderPattern = 'in',
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType: IterationType = IterationType.ITERATIVE
+    iterationType: IterationType = 'ITERATIVE'
   ): ReturnType<C>[] {
     return super.dfs(callback, pattern, beginRoot, iterationType, false);
   }
@@ -650,7 +655,7 @@ export class BST<
     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;
@@ -692,7 +697,7 @@ export class BST<
    */
   lesserOrGreaterTraverse<C extends BTNCallback<NODE>>(
     callback: C = this._defaultOneParamCallback as C,
-    lesserOrGreater: CP = CP.lt,
+    lesserOrGreater: CP = 'LT',
     targetNode: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
@@ -703,7 +708,7 @@ export class BST<
 
     const targetKey = targetNode.key;
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _traverse = (cur: NODE) => {
         const compared = this._compare(cur.key, targetKey);
         if (compared === lesserOrGreater) ans.push(callback(cur));
@@ -752,7 +757,7 @@ export class BST<
     this.clear();
 
     if (sorted.length < 1) return false;
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const buildBalanceBST = (l: number, r: number) => {
         if (l > r) return;
         const m = l + Math.floor((r - l) / 2);
@@ -812,7 +817,7 @@ export class BST<
 
     let balanced = true;
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _height = (cur: NODE | undefined): number => {
         if (!cur) return 0;
         const leftHeight = _height(cur.left),
@@ -856,7 +861,7 @@ export class BST<
    * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. This means that it
    * can either be an object of type `NODE` or it can be `undefined`.
    */
-  protected _setRoot(v: NODE | undefined) {
+  protected override _setRoot(v: NODE | undefined) {
     if (v) {
       v.parent = undefined;
     }
@@ -868,14 +873,32 @@ export class BST<
    * 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).
    */
   protected _compare(a: K, b: K): CP {
     const extractedA = this.extractor(a);
     const extractedB = this.extractor(b);
-    const compared = this.variant === BSTVariant.STANDARD ? extractedA - extractedB : extractedB - extractedA;
+    const compared = this.variant === 'STANDARD' ? extractedA - extractedB : extractedB - extractedA;
 
-    return compared > 0 ? CP.gt : compared < 0 ? CP.lt : CP.eq;
+    return compared > 0 ? 'GT' : compared < 0 ? 'LT' : 'EQ';
+  }
+
+  protected _lt(a: K, b: K): boolean {
+    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;
+  }
+
+  protected _gt(a: K, b: K): boolean {
+    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/src/data-structures/binary-tree/rb-tree.ts

@@ -7,7 +7,7 @@ import type {
   RedBlackTreeNested,
   RedBlackTreeNodeNested
 } from '../../types';
-import { RBTNColor } from '../../types';
+import { CRUD, RBTNColor } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 
@@ -89,26 +89,16 @@ export class RedBlackTree<
     return this._SENTINEL;
   }
 
-  protected _root: NODE | undefined;
+  protected override _root: NODE | undefined;
 
   /**
    * The function returns the root node of a tree or undefined if there is no root.
    * @returns The root node of the tree structure, or undefined if there is no root node.
    */
-  get root(): NODE | undefined {
+  override get root(): NODE | undefined {
     return this._root;
   }
 
-  protected _size: number = 0;
-
-  /**
-   * The function returns the size of an object.
-   * @returns The size of the object, which is a number.
-   */
-  get size(): number {
-    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,
@@ -208,7 +198,7 @@ export class RedBlackTree<
    * @returns a boolean value.
    */
   override isRealNode(node: NODE | undefined): node is NODE {
-    if (node === this._SENTINEL || node === undefined) return false;
+    if (node === this.SENTINEL || node === undefined) return false;
     return node instanceof RedBlackTreeNode;
   }
 
@@ -244,8 +234,7 @@ export class RedBlackTree<
     beginRoot: BSTNKeyOrNode<K, NODE> = this.root,
     iterationType = this.iterationType
   ): NODE | null | undefined {
-    if ((identifier as any) instanceof RedBlackTreeNode) callback = (node => node) as C;
-    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;
   }
 
@@ -262,8 +251,8 @@ export class RedBlackTree<
    * size counter to zero.
    */
   override clear() {
+    super.clear();
     this._root = this.SENTINEL;
-    this._size = 0;
   }
 
   /**
@@ -290,7 +279,7 @@ export class RedBlackTree<
 
     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;
@@ -299,7 +288,7 @@ export class RedBlackTree<
       }
       this._size++;
       return true;
-    } else return insertStatus === 'updated';
+    } else return insertStatus === 'UPDATED';
   }
 
   /**
@@ -434,7 +423,7 @@ export class RedBlackTree<
    * node in the tree.
    * @returns {'inserted' | 'updated'} - The result of the insertion.
    */
-  protected _insert(node: NODE): 'inserted' | 'updated' {
+  protected _insert(node: NODE): CRUD {
     let current = this.root;
     let parent: NODE | undefined = undefined;
 
@@ -446,7 +435,7 @@ export class RedBlackTree<
         current = current.right ?? this.SENTINEL;
       } else {
         this._replaceNode(current, node);
-        return 'updated';
+        return 'UPDATED';
       }
     }
 
@@ -465,7 +454,7 @@ export class RedBlackTree<
     node.color = RBTNColor.RED;
 
     this._insertFixup(node);
-    return 'inserted';
+    return 'CREATED';
   }
 
   /**

package/src/data-structures/binary-tree/tree-multi-map.ts

@@ -14,7 +14,7 @@ import type {
   TreeMultiMapNodeNested,
   TreeMultiMapOptions
 } from '../../types';
-import { IterationType, RBTNColor } from '../../types';
+import { RBTNColor } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
 
@@ -363,7 +363,7 @@ export class TreeMultiMap<
 
     this.clear();
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const buildBalanceBST = (l: number, r: number) => {
         if (l > r) return;
         const m = l + Math.floor((r - l) / 2);

package/src/types/common.ts

@@ -1,13 +1,5 @@
-export enum BSTVariant {
-  STANDARD = 'STANDARD',
-  INVERSE = 'INVERSE'
-}
-
-export enum CP {
-  lt = 'lt',
-  eq = 'eq',
-  gt = 'gt'
-}
+export type BSTVariant = 'STANDARD' | 'INVERSE';
+export type CP = 'LT' | 'EQ' | 'GT';
 
 /**
  * Enum representing different loop types.
@@ -15,20 +7,9 @@ export enum CP {
  * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
  * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
  */
-export enum IterationType {
-  ITERATIVE = 'ITERATIVE',
-  RECURSIVE = 'RECURSIVE'
-}
+export type IterationType = 'ITERATIVE' | 'RECURSIVE';
 
-export enum FamilyPosition {
-  ROOT = 'ROOT',
-  LEFT = 'LEFT',
-  RIGHT = 'RIGHT',
-  ROOT_LEFT = 'ROOT_LEFT',
-  ROOT_RIGHT = 'ROOT_RIGHT',
-  ISOLATED = 'ISOLATED',
-  MAL_NODE = 'MAL_NODE'
-}
+export type FamilyPosition = 'ROOT' | 'LEFT' | 'RIGHT' | 'ROOT_LEFT' | 'ROOT_RIGHT' | 'ISOLATED' | 'MAL_NODE';
 
 export type Comparator<K> = (a: K, b: K) => number;
 
@@ -63,3 +44,5 @@ export type BTNodePureExemplar<K, V, N> = [K, V | undefined] | BTNodePureKeyOrNo
 export type BSTNKeyOrNode<K, N> = K | undefined | N;
 
 export type BinaryTreeDeleteResult<N> = { deleted: N | null | undefined; needBalanced: N | null | undefined };
+
+export type CRUD = 'CREATED' | 'READ' | 'UPDATED' | 'DELETED';