data-structure-typed 1.50.6 → 1.50.8

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';

package/test/integration/all-in-one.test.ts

@@ -1,4 +1,4 @@
-import { AVLTree, CP } from 'data-structure-typed';
+import { AVLTree } from 'data-structure-typed';
 
 describe('AVL Tree Test from data-structure-typed', () => {
   it('should perform various operations on a AVL Tree from data-structure-typed', () => {
@@ -27,7 +27,7 @@ describe('AVL Tree Test from data-structure-typed', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
     expect(lesserSum).toBe(45);
 
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.

package/test/integration/avl-tree.test.ts

@@ -40,7 +40,7 @@ describe('AVL Tree Test', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && tree.subTreeTraverse(node => (subTreeSum += node.key), 15);
+    node15 && tree.dfs(node => (subTreeSum += node.key), 'in', 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;

package/test/integration/bst.test.ts

@@ -34,7 +34,7 @@ describe('Individual package BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && bst.subTreeTraverse(node => (subTreeSum += node.key), 15);
+    node15 && bst.dfs(node => (subTreeSum += node.key), 'in', 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -231,7 +231,7 @@ describe('Individual package BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && objBST.subTreeTraverse(node => (subTreeSum += node.key), node15);
+    node15 && objBST.dfs(node => (subTreeSum += node.key), 'in', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;

package/test/performance/data-structures/binary-tree/rb-tree.test.ts

@@ -11,23 +11,25 @@ const randomArray = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND - 1,
 const cOrderedMap = new OrderedMap<number, number>();
 
 suite
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add orderly`, () => {
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
+    rbTree.clear();
     for (let i = 0; i < randomArray.length; i++) rbTree.add(i);
   })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} delete orderly`, () => {
-    for (let i = 0; i < randomArray.length; i++) rbTree.delete(i);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add randomly`, () => {
-    rbTree.clear();
-    for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
+    for (let i = 0; i < randomArray.length; i++) rbTree.get(randomArray[i]);
   })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} delete randomly`, () => {
-    for (let i = 0; i < randomArray.length; i++) rbTree.delete(randomArray[i]);
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} iterator`, () => {
+    const entries = [...rbTree];
+    return entries.length === HUNDRED_THOUSAND;
   })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add orderly`, () => {
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete orderly`, () => {
+    rbTree.clear();
     for (let i = 0; i < randomArray.length; i++) rbTree.add(i);
+    for (let i = 0; i < randomArray.length; i++) rbTree.delete(i);
   })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} delete randomly`, () => {
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete randomly`, () => {
+    rbTree.clear();
+    for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
     for (let i = 0; i < randomArray.length; i++) rbTree.delete(randomArray[i]);
   });
 
@@ -37,15 +39,4 @@ if (isCompetitor) {
   });
 }
 
-suite.add(`${HUNDRED_THOUSAND.toLocaleString()} getNode randomly`, () => {
-  for (let i = 0; i < randomArray.length; i++) rbTree.getNode(randomArray[i]);
-});
-
-suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & iterator`, () => {
-  rbTree.clear();
-  for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
-  const entries = [...rbTree];
-  return entries.length === HUNDRED_THOUSAND;
-});
-
 export { suite };

package/test/unit/data-structures/binary-tree/avl-tree-multi-map.test.ts

@@ -1,12 +1,4 @@
-import {
-  AVLTreeMultiMap,
-  AVLTreeMultiMapNode,
-  AVLTreeNode,
-  BinaryTreeNode,
-  BSTNode,
-  CP,
-  IterationType
-} from '../../../../src';
+import { AVLTreeMultiMap, AVLTreeMultiMapNode, AVLTreeNode, BinaryTreeNode, BSTNode } from '../../../../src';
 import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
@@ -35,8 +27,11 @@ describe('AVLTreeMultiMap count', () => {
       [2, 2],
       [3, 3]
     ]);
-    tm.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 1);
-    expect(tm.count).toBe(7);
+    tm.add([2, 2], undefined, 10);
+    tm.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 1);
+    tm.delete(2);
+    expect(tm.count).toBe(12);
+    expect(tm.getMutableCount()).toBe(16);
   });
 });
 
@@ -99,7 +94,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'pre', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
-    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), CP.lt, 10);
+    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), 'LT', 10);
     expect(lesserSum).toBe(45);
 
     expect(node15 instanceof AVLTreeMultiMapNode);
@@ -110,7 +105,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     const node11 = treeMultimap.getNode(11);
     expect(node11 instanceof AVLTreeMultiMapNode);
     if (node11 instanceof AVLTreeMultiMapNode) {
-      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
+      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 11);
       expect(allGreaterNodesAdded);
     }
 
@@ -296,7 +291,7 @@ describe('AVLTreeMultiMap operations test1', () => {
 
 describe('AVLTreeMultiMap operations test recursively1', () => {
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const treeMultimap = new AVLTreeMultiMap<number>([], { iterationType: IterationType.RECURSIVE });
+    const treeMultimap = new AVLTreeMultiMap<number>([], { iterationType: 'RECURSIVE' });
 
     expect(treeMultimap instanceof AVLTreeMultiMap);
     treeMultimap.add([11, 11]);
@@ -353,7 +348,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'pre', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
-    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), CP.lt, 10);
+    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), 'LT', 10);
     expect(lesserSum).toBe(45);
 
     expect(node15 instanceof AVLTreeMultiMapNode);
@@ -364,7 +359,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     const node11 = treeMultimap.getNode(11);
     expect(node11 instanceof AVLTreeMultiMapNode);
     if (node11 instanceof AVLTreeMultiMapNode) {
-      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
+      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 11);
       expect(allGreaterNodesAdded);
     }
 
@@ -569,7 +564,7 @@ describe('AVLTreeMultiMap Performance test', function () {
     }
     isDebug && console.log('---add', performance.now() - start);
     const startL = performance.now();
-    treeMS.lesserOrGreaterTraverse(node => (node.count += 1), CP.lt, inputSize / 2);
+    treeMS.lesserOrGreaterTraverse(node => (node.count += 1), 'LT', inputSize / 2);
     isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);
   });
 

package/test/unit/data-structures/binary-tree/avl-tree.test.ts

@@ -1,4 +1,4 @@
-import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode, CP, IterationType } from '../../../../src';
+import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode } from '../../../../src';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
@@ -28,7 +28,7 @@ describe('AVL Tree Test', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
     expect(lesserSum).toBe(45);
 
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
@@ -112,7 +112,7 @@ describe('AVL Tree Test', () => {
 describe('AVL Tree Test recursively', () => {
   it('should perform various operations on a AVL Tree', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    const tree = new AVLTree<number>([], { iterationType: IterationType.RECURSIVE });
+    const tree = new AVLTree<number>([], { iterationType: 'RECURSIVE' });
 
     for (const i of arr) tree.add([i, i]);
 
@@ -136,7 +136,7 @@ describe('AVL Tree Test recursively', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
     expect(lesserSum).toBe(45);
 
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.