data-structure-typed 1.50.6 → 1.50.7

package/dist/umd/data-structure-typed.js

@@ -115,6 +115,7 @@ var dataStructureTyped = (() => {
     BinaryTree: () => BinaryTree,
     BinaryTreeNode: () => BinaryTreeNode,
     CP: () => CP,
+    CRUD: () => CRUD,
     Character: () => Character,
     Deque: () => Deque,
     DirectedEdge: () => DirectedEdge,
@@ -7689,6 +7690,13 @@ var dataStructureTyped = (() => {
     FamilyPosition2["MAL_NODE"] = "MAL_NODE";
     return FamilyPosition2;
   })(FamilyPosition || {});
+  var CRUD = /* @__PURE__ */ ((CRUD2) => {
+    CRUD2["CREATED"] = "CREATED";
+    CRUD2["READ"] = "READ";
+    CRUD2["UPDATED"] = "UPDATED";
+    CRUD2["DELETED"] = "DELETED";
+    return CRUD2;
+  })(CRUD || {});
 
   // src/data-structures/binary-tree/binary-tree.ts
   var BinaryTreeNode = class {
@@ -8469,7 +8477,7 @@ var dataStructureTyped = (() => {
      */
     getHeight(beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNode(beginRoot);
-      if (!beginRoot)
+      if (!this.isRealNode(beginRoot))
         return -1;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
         const _getMaxHeight = (cur) => {
@@ -8518,9 +8526,9 @@ var dataStructureTyped = (() => {
         return -1;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
         const _getMinHeight = (cur) => {
-          if (!cur)
+          if (!this.isRealNode(cur))
             return 0;
-          if (!cur.left && !cur.right)
+          if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
             return 0;
           const leftMinHeight = _getMinHeight(cur.left);
           const rightMinHeight = _getMinHeight(cur.right);
@@ -8532,16 +8540,16 @@ var dataStructureTyped = (() => {
         let node = beginRoot, last = null;
         const depths = /* @__PURE__ */ 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 ? (_a = depths.get(node.left)) != null ? _a : -1 : -1;
-                const rightMinHeight = node.right ? (_b = depths.get(node.right)) != null ? _b : -1 : -1;
+              if (this.isRealNode(node)) {
+                const leftMinHeight = this.isRealNode(node.left) ? (_a = depths.get(node.left)) != null ? _a : -1 : -1;
+                const rightMinHeight = this.isRealNode(node.right) ? (_b = depths.get(node.right)) != null ? _b : -1 : -1;
                 depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
                 last = node;
                 node = null;
@@ -8603,8 +8611,10 @@ var dataStructureTyped = (() => {
      * is no leftmost node, it returns `null` or `undefined` depending on the input.
      */
     getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
+      if (this.isNIL(beginRoot))
+        return beginRoot;
       beginRoot = this.ensureNode(beginRoot);
-      if (!beginRoot)
+      if (!this.isRealNode(beginRoot))
         return beginRoot;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
         const _traverse = (cur) => {
@@ -8642,6 +8652,8 @@ var dataStructureTyped = (() => {
      * is no rightmost node, it returns `null` or `undefined`, depending on the input.
      */
     getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
+      if (this.isNIL(beginRoot))
+        return beginRoot;
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return beginRoot;
@@ -9707,17 +9719,17 @@ var dataStructureTyped = (() => {
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
     getNodeByKey(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
-      if (!this.root)
+      if (!this.isRealNode(this.root))
         return void 0;
       if (iterationType === "RECURSIVE" /* 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) === "gt" /* gt */ && cur.left)
+          if (this._compare(cur.key, key) === "gt" /* gt */ && this.isRealNode(cur.left))
             return _dfs(cur.left);
-          if (this._compare(cur.key, key) === "lt" /* lt */ && cur.right)
+          if (this._compare(cur.key, key) === "lt" /* lt */ && this.isRealNode(cur.right))
             return _dfs(cur.right);
         };
         return _dfs(this.root);
@@ -9725,13 +9737,13 @@ var dataStructureTyped = (() => {
         const queue = new Queue([this.root]);
         while (queue.size > 0) {
           const cur = queue.shift();
-          if (cur) {
+          if (this.isRealNode(cur)) {
             if (this._compare(cur.key, key) === "eq" /* eq */)
               return cur;
             if (this._compare(cur.key, key) === "gt" /* gt */)
-              cur.left && queue.push(cur.left);
+              this.isRealNode(cur.left) && queue.push(cur.left);
             if (this._compare(cur.key, key) === "lt" /* lt */)
-              cur.right && queue.push(cur.right);
+              this.isRealNode(cur.right) && queue.push(cur.right);
           }
         }
       }
@@ -9777,16 +9789,16 @@ var dataStructureTyped = (() => {
             if (onlyOne)
               return;
           }
-          if (!cur.left && !cur.right)
+          if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
             return;
           if (callback === this._defaultOneParamCallback) {
             if (this._compare(cur.key, identifier) === "gt" /* gt */)
-              cur.left && _traverse(cur.left);
+              this.isRealNode(cur.left) && _traverse(cur.left);
             if (this._compare(cur.key, identifier) === "lt" /* lt */)
-              cur.right && _traverse(cur.right);
+              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);
           }
         };
         _traverse(beginRoot);
@@ -9794,7 +9806,7 @@ var dataStructureTyped = (() => {
         const queue = new Queue([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);
@@ -9803,12 +9815,12 @@ var dataStructureTyped = (() => {
             }
             if (callback === this._defaultOneParamCallback) {
               if (this._compare(cur.key, identifier) === "gt" /* gt */)
-                cur.left && queue.push(cur.left);
+                this.isRealNode(cur.left) && queue.push(cur.left);
               if (this._compare(cur.key, identifier) === "lt" /* lt */)
-                cur.right && queue.push(cur.right);
+                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);
             }
           }
         }
@@ -11189,7 +11201,6 @@ var dataStructureTyped = (() => {
       super([], options);
       __publicField(this, "_SENTINEL", new RedBlackTreeNode(NaN));
       __publicField(this, "_root");
-      __publicField(this, "_size", 0);
       this._root = this.SENTINEL;
       if (keysOrNodesOrEntries) {
         this.addMany(keysOrNodesOrEntries);
@@ -11209,13 +11220,6 @@ var dataStructureTyped = (() => {
     get root() {
       return this._root;
     }
-    /**
-     * 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,
@@ -11307,7 +11311,7 @@ var dataStructureTyped = (() => {
      * @returns a boolean value.
      */
     isRealNode(node) {
-      if (node === this._SENTINEL || node === void 0)
+      if (node === this.SENTINEL || node === void 0)
         return false;
       return node instanceof RedBlackTreeNode;
     }
@@ -11340,8 +11344,7 @@ var dataStructureTyped = (() => {
       var _a;
       if (identifier instanceof RedBlackTreeNode)
         callback = (node) => node;
-      beginRoot = this.ensureNode(beginRoot);
-      return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) != null ? _a : void 0;
+      return (_a = super.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) != null ? _a : void 0;
     }
     /**
      * Time Complexity: O(1)
@@ -11355,8 +11358,8 @@ var dataStructureTyped = (() => {
      * size counter to zero.
      */
     clear() {
+      super.clear();
       this._root = this.SENTINEL;
-      this._size = 0;
     }
     /**
      * Time Complexity: O(log n)
@@ -11380,7 +11383,7 @@ var dataStructureTyped = (() => {
       if (!this.isRealNode(newNode))
         return false;
       const insertStatus = this._insert(newNode);
-      if (insertStatus === "inserted") {
+      if (insertStatus === "CREATED" /* CREATED */) {
         if (this.isRealNode(this._root)) {
           this._root.color = 0 /* BLACK */;
         } else {
@@ -11389,7 +11392,7 @@ var dataStructureTyped = (() => {
         this._size++;
         return true;
       } else
-        return insertStatus === "updated";
+        return insertStatus === "UPDATED" /* UPDATED */;
     }
     /**
      * Time Complexity: O(log n)
@@ -11516,7 +11519,7 @@ var dataStructureTyped = (() => {
           current = (_b = current.right) != null ? _b : this.SENTINEL;
         } else {
           this._replaceNode(current, node);
-          return "updated";
+          return "UPDATED" /* UPDATED */;
         }
       }
       node.parent = parent;
@@ -11531,7 +11534,7 @@ var dataStructureTyped = (() => {
       node.right = this.SENTINEL;
       node.color = 1 /* RED */;
       this._insertFixup(node);
-      return "inserted";
+      return "CREATED" /* CREATED */;
     }
     /**
      * Time Complexity: O(1)
@@ -11807,6 +11810,9 @@ var dataStructureTyped = (() => {
      * @returns the sum of the count property of all nodes in the tree.
      */
     get count() {
+      return this._count;
+    }
+    getMutableCount() {
       let sum = 0;
       this.dfs((node) => sum += node.count);
       return sum;