min-heap-typed 1.50.4 → 1.50.6

package/dist/data-structures/base/iterable-base.d.ts

@@ -4,6 +4,7 @@ export declare abstract class IterableEntryBase<K = any, V = any> {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
+    abstract get size(): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -91,6 +92,10 @@ export declare abstract class IterableEntryBase<K = any, V = any> {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -171,10 +176,6 @@ export declare abstract class IterableEntryBase<K = any, V = any> {
      * collection, otherwise it returns `undefined`.
      */
     get(key: K): V | undefined;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -205,6 +206,7 @@ export declare abstract class IterableEntryBase<K = any, V = any> {
     protected abstract _getIterator(...args: any[]): IterableIterator<[K, V]>;
 }
 export declare abstract class IterableElementBase<E = any, C = any> {
+    abstract get size(): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -253,6 +255,10 @@ export declare abstract class IterableElementBase<E = any, C = any> {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -307,10 +313,6 @@ export declare abstract class IterableElementBase<E = any, C = any> {
      * callback function. If no element satisfies the callback function, `undefined` is returned.
      */
     find(callbackfn: ElementCallback<E, boolean>, thisArg?: any): E | undefined;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)

package/dist/data-structures/base/iterable-base.js

@@ -2,10 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IterableElementBase = exports.IterableEntryBase = void 0;
 class IterableEntryBase {
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -123,6 +119,10 @@ class IterableEntryBase {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -237,10 +237,6 @@ class IterableEntryBase {
         }
         return;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -338,6 +334,10 @@ class IterableElementBase {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -412,10 +412,6 @@ class IterableElementBase {
         }
         return;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)

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

@@ -736,7 +736,7 @@ class BinaryTree extends base_1.IterableEntryBase {
             return true;
         if (iterationType === types_1.IterationType.RECURSIVE) {
             const dfs = (cur, min, max) => {
-                if (!cur)
+                if (!this.isRealNode(cur))
                     return true;
                 const numKey = this.extractor(cur.key);
                 if (numKey <= min || numKey >= max)
@@ -753,14 +753,14 @@ class BinaryTree extends base_1.IterableEntryBase {
                 let prev = checkMax ? Number.MAX_SAFE_INTEGER : Number.MIN_SAFE_INTEGER;
                 // @ts-ignore
                 let curr = beginRoot;
-                while (curr || stack.length > 0) {
-                    while (curr) {
+                while (this.isRealNode(curr) || stack.length > 0) {
+                    while (this.isRealNode(curr)) {
                         stack.push(curr);
                         curr = curr.left;
                     }
                     curr = stack.pop();
                     const numKey = this.extractor(curr.key);
-                    if (!curr || (!checkMax && prev >= numKey) || (checkMax && prev <= numKey))
+                    if (!this.isRealNode(curr) || (!checkMax && prev >= numKey) || (checkMax && prev <= numKey))
                         return false;
                     prev = numKey;
                     curr = curr.right;
@@ -825,7 +825,7 @@ class BinaryTree extends base_1.IterableEntryBase {
             return -1;
         if (iterationType === types_1.IterationType.RECURSIVE) {
             const _getMaxHeight = (cur) => {
-                if (!cur)
+                if (!this.isRealNode(cur))
                     return -1;
                 const leftHeight = _getMaxHeight(cur.left);
                 const rightHeight = _getMaxHeight(cur.right);
@@ -838,9 +838,9 @@ class BinaryTree extends base_1.IterableEntryBase {
             let maxHeight = 0;
             while (stack.length > 0) {
                 const { node, depth } = stack.pop();
-                if (node.left)
+                if (this.isRealNode(node.left))
                     stack.push({ node: node.left, depth: depth + 1 });
-                if (node.right)
+                if (this.isRealNode(node.right))
                     stack.push({ node: node.right, depth: depth + 1 });
                 maxHeight = Math.max(maxHeight, depth);
             }
@@ -1117,48 +1117,48 @@ class BinaryTree extends base_1.IterableEntryBase {
                 switch (pattern) {
                     case 'in':
                         if (includeNull) {
-                            if (node && this.isNodeOrNull(node.left))
+                            if (this.isRealNode(node) && this.isNodeOrNull(node.left))
                                 _traverse(node.left);
                             this.isNodeOrNull(node) && ans.push(callback(node));
-                            if (node && this.isNodeOrNull(node.right))
+                            if (this.isRealNode(node) && this.isNodeOrNull(node.right))
                                 _traverse(node.right);
                         }
                         else {
-                            if (node && node.left)
+                            if (this.isRealNode(node) && this.isRealNode(node.left))
                                 _traverse(node.left);
                             this.isRealNode(node) && ans.push(callback(node));
-                            if (node && node.right)
+                            if (this.isRealNode(node) && this.isRealNode(node.right))
                                 _traverse(node.right);
                         }
                         break;
                     case 'pre':
                         if (includeNull) {
                             this.isNodeOrNull(node) && ans.push(callback(node));
-                            if (node && this.isNodeOrNull(node.left))
+                            if (this.isRealNode(node) && this.isNodeOrNull(node.left))
                                 _traverse(node.left);
-                            if (node && this.isNodeOrNull(node.right))
+                            if (this.isRealNode(node) && this.isNodeOrNull(node.right))
                                 _traverse(node.right);
                         }
                         else {
                             this.isRealNode(node) && ans.push(callback(node));
-                            if (node && node.left)
+                            if (this.isRealNode(node) && this.isRealNode(node.left))
                                 _traverse(node.left);
-                            if (node && node.right)
+                            if (this.isRealNode(node) && this.isRealNode(node.right))
                                 _traverse(node.right);
                         }
                         break;
                     case 'post':
                         if (includeNull) {
-                            if (node && this.isNodeOrNull(node.left))
+                            if (this.isRealNode(node) && this.isNodeOrNull(node.left))
                                 _traverse(node.left);
-                            if (node && this.isNodeOrNull(node.right))
+                            if (this.isRealNode(node) && this.isNodeOrNull(node.right))
                                 _traverse(node.right);
                             this.isNodeOrNull(node) && ans.push(callback(node));
                         }
                         else {
-                            if (node && node.left)
+                            if (this.isRealNode(node) && this.isRealNode(node.left))
                                 _traverse(node.left);
-                            if (node && node.right)
+                            if (this.isRealNode(node) && this.isRealNode(node.right))
                                 _traverse(node.right);
                             this.isRealNode(node) && ans.push(callback(node));
                         }