data-structure-typed 1.36.9 → 1.37.1

package/lib/data-structures/binary-tree/tree-multiset.js

@@ -1,5 +1,6 @@
 import { CP, FamilyPosition, LoopType } from '../../types';
 import { AVLTree, AVLTreeNode } from './avl-tree';
+import { Queue } from '../queue';
 export class TreeMultisetNode extends AVLTreeNode {
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
@@ -321,110 +322,6 @@ export class TreeMultiset extends AVLTree {
         }
         return bstDeletedResult;
     }
-    /**
-     * The function `getSubTreeCount` calculates the number of nodes and the sum of their counts in a subtree, using either
-     * recursive or iterative traversal.
-     * @param {N | null | undefined} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree in a
-     * binary tree.
-     * @returns The function `getSubTreeCount` returns an array `[number, number]`.
-     */
-    getSubTreeCount(subTreeRoot) {
-        const res = [0, 0];
-        if (!subTreeRoot)
-            return res;
-        if (this.loopType === LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                res[0]++;
-                res[1] += cur.count;
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
-            };
-            _traverse(subTreeRoot);
-            return res;
-        }
-        else {
-            const stack = [subTreeRoot];
-            while (stack.length > 0) {
-                const cur = stack.pop();
-                res[0]++;
-                res[1] += cur.count;
-                cur.right && stack.push(cur.right);
-                cur.left && stack.push(cur.left);
-            }
-            return res;
-        }
-    }
-    /**
-     * The function `subTreeSumCount` calculates the sum of the `count` property of each node in a subtree, either
-     * recursively or iteratively.
-     * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
-     * in a binary tree. It can be either a `BinaryTreeNodeKey` (a unique identifier for a node in the binary tree) or
-     * `null` if the subtree is empty.
-     * @returns the sum of the count values of all nodes in the subtree rooted at `subTreeRoot`.
-     */
-    subTreeSumCount(subTreeRoot) {
-        if (typeof subTreeRoot === 'number')
-            subTreeRoot = this.get(subTreeRoot, 'key');
-        if (!subTreeRoot)
-            return 0;
-        let sum = 0;
-        if (this.loopType === LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                sum += cur.count;
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
-            };
-            _traverse(subTreeRoot);
-        }
-        else {
-            const stack = [subTreeRoot];
-            while (stack.length > 0) {
-                const cur = stack.pop();
-                sum += cur.count;
-                cur.right && stack.push(cur.right);
-                cur.left && stack.push(cur.left);
-            }
-        }
-        return sum;
-    }
-    /**
-     * The function `subTreeAddCount` recursively or iteratively traverses a binary tree and adds a given delta value to
-     * the `count` property of each node.
-     * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
-     * in a binary tree. It can be either a `BinaryTreeNodeKey` (a unique identifier for a node in the binary tree), a
-     * `BinaryTreeNode` object, or `null` if the subtree is empty.
-     * @param {number} delta - The delta parameter is a number that represents the amount by which the count of each node
-     * in the subtree should be increased or decreased.
-     * @returns a boolean value.
-     */
-    subTreeAddCount(subTreeRoot, delta) {
-        if (typeof subTreeRoot === 'number')
-            subTreeRoot = this.get(subTreeRoot, 'key');
-        if (!subTreeRoot)
-            return false;
-        const _addByProperty = (cur) => {
-            cur.count += delta;
-            this._setCount(this.count + delta);
-        };
-        if (this.loopType === LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                _addByProperty(cur);
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
-            };
-            _traverse(subTreeRoot);
-        }
-        else {
-            const stack = [subTreeRoot];
-            while (stack.length > 0) {
-                const cur = stack.pop();
-                _addByProperty(cur);
-                cur.right && stack.push(cur.right);
-                cur.left && stack.push(cur.left);
-            }
-        }
-        return true;
-    }
     /**
      * The function `getNodesByCount` returns an array of nodes that have a specific count property, either recursively or
      * using a queue.
@@ -454,8 +351,8 @@ export class TreeMultiset extends AVLTree {
             _traverse(this.root);
         }
         else {
-            const queue = [this.root];
-            while (queue.length > 0) {
+            const queue = new Queue([this.root]);
+            while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
                     if (cur.count === nodeProperty) {
@@ -502,140 +399,6 @@ export class TreeMultiset extends AVLTree {
         const nodes = super.morris(pattern, 'node');
         return nodes.map(node => node.count);
     }
-    /**
-     * The function dfsCountIterative performs an iterative depth-first search and returns an array of node counts based on
-     * the specified traversal pattern.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The pattern parameter is a string that specifies the traversal order for
-     * the Depth-First Search (dfs) algorithm. It can have three possible values: 'in', 'pre', or 'post'.
-     * @param loopType  - The loopType parameter is a string that specifies the type of loop to use when traversing the
-     * @returns The dfsCountIterative function returns an array of numbers, which represents the count property of each node
-     * in the dfs traversal.
-     */
-    dfsCount(pattern = 'in', loopType = LoopType.ITERATIVE) {
-        const nodes = super.dfs(pattern, 'node', loopType);
-        return nodes.map(node => node.count);
-    }
-    /**
-     * The `lesserSumCount` function calculates the sum of the counts of all nodes in a binary tree that have a lesser
-     * value than a given node.
-     * @param {N | BinaryTreeNodeKey | null} beginNode - The `beginNode` parameter can be one of the following:
-     * @returns the sum of the counts of nodes in the binary tree that have a lesser value than the given beginNode.
-     */
-    lesserSumCount(beginNode) {
-        if (typeof beginNode === 'number')
-            beginNode = this.get(beginNode, 'key');
-        if (!beginNode)
-            return 0;
-        if (!this.root)
-            return 0;
-        const key = beginNode.key;
-        let sum = 0;
-        if (this.loopType === LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                const compared = this._compare(cur.key, key);
-                if (compared === CP.eq) {
-                    if (cur.right)
-                        sum += this.subTreeSumCount(cur.right);
-                    return;
-                }
-                else if (compared === CP.lt) {
-                    if (cur.left)
-                        sum += this.subTreeSumCount(cur.left);
-                    sum += cur.count;
-                    if (cur.right)
-                        _traverse(cur.right);
-                    else
-                        return;
-                }
-                else {
-                    if (cur.left)
-                        _traverse(cur.left);
-                    else
-                        return;
-                }
-            };
-            _traverse(this.root);
-        }
-        else {
-            const queue = [this.root];
-            while (queue.length > 0) {
-                const cur = queue.shift();
-                if (cur) {
-                    const compared = this._compare(cur.key, key);
-                    if (compared === CP.eq) {
-                        if (cur.right)
-                            sum += this.subTreeSumCount(cur.right);
-                        return sum;
-                    }
-                    else if (compared === CP.lt) {
-                        // todo maybe a bug
-                        if (cur.left)
-                            sum += this.subTreeSumCount(cur.left);
-                        sum += cur.count;
-                        if (cur.right)
-                            queue.push(cur.right);
-                        else
-                            return sum;
-                    }
-                    else {
-                        if (cur.left)
-                            queue.push(cur.left);
-                        else
-                            return sum;
-                    }
-                }
-            }
-        }
-        return sum;
-    }
-    /**
-     * The function `allGreaterNodesAddCount` updates the count property of all nodes in a binary tree that have an ID
-     * greater than a given ID by a specified delta value.
-     * @param {N | BinaryTreeNodeKey | null} node - The `node` parameter can be one of the following:
-     * @param {number} delta - The `delta` parameter is a number that represents the amount by which the `count` property
-     * of each node should be increased.
-     * @returns a boolean value.
-     */
-    allGreaterNodesAddCount(node, delta) {
-        if (typeof node === 'number')
-            node = this.get(node, 'key');
-        if (!node)
-            return false;
-        const key = node.key;
-        if (!this.root)
-            return false;
-        if (this.loopType === LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                const compared = this._compare(cur.key, key);
-                if (compared === CP.gt)
-                    cur.count += delta;
-                if (!cur.left && !cur.right)
-                    return;
-                if (cur.left && this._compare(cur.left.key, key) === CP.gt)
-                    _traverse(cur.left);
-                if (cur.right && this._compare(cur.right.key, key) === CP.gt)
-                    _traverse(cur.right);
-            };
-            _traverse(this.root);
-            return true;
-        }
-        else {
-            const queue = [this.root];
-            while (queue.length > 0) {
-                const cur = queue.shift();
-                if (cur) {
-                    const compared = this._compare(cur.key, key);
-                    if (compared === CP.gt)
-                        cur.count += delta;
-                    if (cur.left && this._compare(cur.left.key, key) === CP.gt)
-                        queue.push(cur.left);
-                    if (cur.right && this._compare(cur.right.key, key) === CP.gt)
-                        queue.push(cur.right);
-                }
-            }
-            return true;
-        }
-    }
     /**
      * The clear() function clears the data and sets the count to 0.
      */

package/lib/data-structures/graph/abstract-graph.js

@@ -7,6 +7,7 @@
  */
 import { arrayRemove, uuidV4 } from '../../utils';
 import { PriorityQueue } from '../priority-queue';
+import { Queue } from '../queue';
 export class AbstractVertex {
     /**
      * The function is a protected constructor that takes an key and an optional value as parameters.
@@ -265,11 +266,11 @@ export class AbstractGraph {
                 return null;
             }
             const visited = new Map();
-            const queue = [vertex1];
+            const queue = new Queue([vertex1]);
             visited.set(vertex1, true);
             let cost = 0;
-            while (queue.length > 0) {
-                for (let i = 0; i < queue.length; i++) {
+            while (queue.size > 0) {
+                for (let i = 0; i < queue.size; i++) {
                     const cur = queue.shift();
                     if (cur === vertex2) {
                         return cost;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.36.9",
+  "version": "1.37.1",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/index.js",
   "module": "lib/index.js",
@@ -33,8 +33,10 @@
     "check:deps": "dependency-cruiser src",
     "changelog": "auto-changelog",
     "coverage:badge": "istanbul-badges-readme",
-    "ci": "env && npm run lint && npm run build && npm run update:individuals && npm run test && git fetch --tags && npm run changelog",
-    "publish:all": "npm run ci && npm publish && sh scripts/publish_all_subs.sh && sh scripts/publish_docs.sh"
+    "ci": "env && git fetch --tags && npm run lint && npm run build && npm run update:individuals && npm run test && npm run changelog",
+    "publish:individuals": "sh scripts/publish_all_subs.sh",
+    "publish:docs": "sh scripts/publish_docs.sh",
+    "publish:all": "npm run ci && npm publish && npm run publish:individuals && npm run publish:docs"
   },
   "repository": {
     "type": "git",
@@ -56,17 +58,17 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.36.8",
+    "avl-tree-typed": "^1.36.9",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.36.8",
-    "bst-typed": "^1.36.8",
+    "binary-tree-typed": "^1.36.9",
+    "bst-typed": "^1.36.9",
     "dependency-cruiser": "^14.1.0",
     "eslint": "^8.50.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-import-resolver-alias": "^1.1.2",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
-    "heap-typed": "^1.36.8",
+    "heap-typed": "^1.36.9",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",