data-structure-typed 1.50.6 → 1.50.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.50.6",
+  "version": "1.50.7",
   "description": "Javascript Data Structure. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",

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

@@ -83,6 +83,10 @@ export class AVLTreeMultiMap<
    * @returns the sum of the count property of all nodes in the tree.
    */
   get count(): number {
+    return this._count;
+  }
+
+  getMutableCount(): number {
     let sum = 0;
     this.dfs(node => (sum += node.count));
     return sum;
@@ -414,7 +418,7 @@ export class AVLTreeMultiMap<
    * @returns The method is returning the result of calling the `_replaceNode` method from the
    * superclass, after updating the `count` property of the `newNode` object.
    */
-  protected _replaceNode(oldNode: NODE, newNode: NODE): NODE {
+  protected override _replaceNode(oldNode: NODE, newNode: NODE): NODE {
     newNode.count = oldNode.count + newNode.count;
     return super._replaceNode(oldNode, newNode);
   }

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

@@ -522,7 +522,7 @@ export class AVLTree<
    * @returns the result of calling the `_replaceNode` method on the superclass, passing in the
    * `oldNode` and `newNode` as arguments.
    */
-  protected _replaceNode(oldNode: NODE, newNode: NODE): NODE {
+  protected override _replaceNode(oldNode: NODE, newNode: NODE): NODE {
     newNode.height = oldNode.height;
 
     return super._replaceNode(oldNode, newNode);

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

@@ -1021,7 +1021,7 @@ export class BinaryTree<
    */
   getHeight(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, iterationType = this.iterationType): number {
     beginRoot = this.ensureNode(beginRoot);
-    if (!beginRoot) return -1;
+    if (!this.isRealNode(beginRoot)) return -1;
 
     if (iterationType === IterationType.RECURSIVE) {
       const _getMaxHeight = (cur: NODE | null | undefined): number => {
@@ -1073,8 +1073,8 @@ export class BinaryTree<
 
     if (iterationType === IterationType.RECURSIVE) {
       const _getMinHeight = (cur: NODE | null | undefined): number => {
-        if (!cur) return 0;
-        if (!cur.left && !cur.right) return 0;
+        if (!this.isRealNode(cur)) return 0;
+        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return 0;
         const leftMinHeight = _getMinHeight(cur.left);
         const rightMinHeight = _getMinHeight(cur.right);
         return Math.min(leftMinHeight, rightMinHeight) + 1;
@@ -1088,16 +1088,16 @@ export class BinaryTree<
       const depths: Map<NODE, number> = new Map();
 
       while (stack.length > 0 || node) {
-        if (node) {
+        if (this.isRealNode(node)) {
           stack.push(node);
           node = node.left;
         } else {
           node = stack[stack.length - 1];
-          if (!node.right || last === node.right) {
+          if (!this.isRealNode(node.right) || last === node.right) {
             node = stack.pop();
-            if (node) {
-              const leftMinHeight = node.left ? depths.get(node.left) ?? -1 : -1;
-              const rightMinHeight = node.right ? depths.get(node.right) ?? -1 : -1;
+            if (this.isRealNode(node)) {
+              const leftMinHeight = this.isRealNode(node.left) ? depths.get(node.left) ?? -1 : -1;
+              const rightMinHeight = this.isRealNode(node.right) ? depths.get(node.right) ?? -1 : -1;
               depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
               last = node;
               node = null;
@@ -1169,9 +1169,10 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType = this.iterationType
   ): NODE | null | undefined {
+    if (this.isNIL(beginRoot)) return beginRoot as NODE;
     beginRoot = this.ensureNode(beginRoot);
 
-    if (!beginRoot) return beginRoot;
+    if (!this.isRealNode(beginRoot)) return beginRoot;
 
     if (iterationType === IterationType.RECURSIVE) {
       const _traverse = (cur: NODE): NODE => {
@@ -1215,6 +1216,7 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType = this.iterationType
   ): NODE | null | undefined {
+    if (this.isNIL(beginRoot)) return beginRoot as NODE;
     // TODO support get right most by passing key in
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return beginRoot;
@@ -1837,7 +1839,7 @@ export class BinaryTree<
    * following types:
    * @param {BinaryTreePrintOptions} [options={ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false}] - Options object that controls printing behavior. You can specify whether to display undefined, null, or sentinel nodes.
    */
-  print(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, options?: BinaryTreePrintOptions): void {
+  override print(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, options?: BinaryTreePrintOptions): void {
     const opts = { isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false, ...options };
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return;

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

@@ -426,14 +426,14 @@ export class BST<
    * 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 (!this.isRealNode(this.root)) return undefined;
     if (iterationType === 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) === CP.gt && this.isRealNode(cur.left)) return _dfs(cur.left);
+        if (this._compare(cur.key, key) === CP.lt && this.isRealNode(cur.right)) return _dfs(cur.right);
       };
 
       return _dfs(this.root);
@@ -441,10 +441,10 @@ export class BST<
       const queue = new Queue<NODE>([this.root]);
       while (queue.size > 0) {
         const cur = queue.shift();
-        if (cur) {
+        if (this.isRealNode(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._compare(cur.key, key) === CP.gt) this.isRealNode(cur.left) && queue.push(cur.left);
+          if (this._compare(cur.key, key) === CP.lt) this.isRealNode(cur.right) && queue.push(cur.right);
         }
       }
     }
@@ -497,14 +497,14 @@ 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._compare(cur.key, identifier as K) === CP.gt) this.isRealNode(cur.left) && _traverse(cur.left);
+          if (this._compare(cur.key, identifier as K) === CP.lt) this.isRealNode(cur.right) && _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);
         }
       };
 
@@ -513,7 +513,7 @@ export class BST<
       const queue = new Queue<NODE>([beginRoot]);
       while (queue.size > 0) {
         const cur = queue.shift();
-        if (cur) {
+        if (this.isRealNode(cur)) {
           const callbackResult = callback(cur);
           if (callbackResult === identifier) {
             ans.push(cur);
@@ -521,11 +521,11 @@ 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._compare(cur.key, identifier as K) === CP.gt) this.isRealNode(cur.left) && queue.push(cur.left);
+            if (this._compare(cur.key, identifier as K) === CP.lt) this.isRealNode(cur.right) && queue.push(cur.right);
           } else {
-            cur.left && queue.push(cur.left);
-            cur.right && queue.push(cur.right);
+            this.isRealNode(cur.left) && queue.push(cur.left);
+            this.isRealNode(cur.right) && queue.push(cur.right);
           }
         }
       }
@@ -856,7 +856,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;
     }

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;
   }
 
@@ -245,8 +235,7 @@ export class RedBlackTree<
     iterationType = this.iterationType
   ): NODE | null | undefined {
     if ((identifier as any) instanceof RedBlackTreeNode) callback = (node => node) as C;
-    beginRoot = this.ensureNode(beginRoot);
-    return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
+    return super.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 === CRUD.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 === CRUD.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 CRUD.UPDATED;
       }
     }
 
@@ -465,7 +454,7 @@ export class RedBlackTree<
     node.color = RBTNColor.RED;
 
     this._insertFixup(node);
-    return 'inserted';
+    return CRUD.CREATED;
   }
 
   /**

package/src/types/common.ts

@@ -63,3 +63,10 @@ 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 enum CRUD {
+  CREATED = 'CREATED',
+  READ = 'READ',
+  UPDATED = 'UPDATED',
+  DELETED = 'DELETED'
+}

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

@@ -35,8 +35,11 @@ describe('AVLTreeMultiMap count', () => {
       [2, 2],
       [3, 3]
     ]);
+    tm.add([2, 2], undefined, 10);
     tm.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 1);
-    expect(tm.count).toBe(7);
+    tm.delete(2);
+    expect(tm.count).toBe(12);
+    expect(tm.getMutableCount()).toBe(16);
   });
 });