data-structure-typed 1.15.2 → 1.16.1

package/{tests/unit/data-structures/binary-tree → notes}/bst.test.ts

@@ -1,40 +1,32 @@
-import {BST, BSTNode} from '../../../../src';
+import {BST, BSTNode} from '../../../src';
 
-describe('BST Case6', () => {
+describe('testBSTCase6', () => {
     it('should perform various operations on a Binary Search Tree', () => {
-
+        const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+        const clonedData = [...arr];
         const tree = new BST();
-        expect(tree).toBeInstanceOf(BST);
-
-        const values = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-        tree.addMany(values);
-        expect(tree.root).toBeInstanceOf(BSTNode);
 
-        if (tree.root) expect(tree.root.id).toBe(11);
-
-        expect(tree.count).toBe(16);
+        for (const i of clonedData) {
+            tree.put(i, i);
+        }
 
         expect(tree.has(6)).toBe(true);
 
         const node6 = tree.get(6);
         expect(node6 && tree.getHeight(node6)).toBe(2);
         expect(node6 && tree.getDepth(node6)).toBe(3);
+        const getNodeById = tree.get(10, 'id');
+        expect(getNodeById?.id).toBe(10);
 
-        const nodeId10 = tree.get(10, 'id');
-        expect(nodeId10?.id).toBe(10);
+        const getNodesByCount = tree.getNodes(1, 'count');
+        expect(getNodesByCount.length).toBe(16);
 
-        const nodeVal9 = tree.get(9, 'val');
-        expect(nodeVal9?.id).toBe(9);
-
-        const nodesByCount1 = tree.getNodes(1, 'count');
-        expect(nodesByCount1.length).toBe(16);
-
-        const leftMost = tree.getLeftMost();
-        expect(leftMost?.id).toBe(1);
+        const getMinNodeByRoot = tree.getLeftMost();
+        expect(getMinNodeByRoot?.id).toBe(1);
 
         const node15 = tree.get(15);
-        const minNodeBySpecificNode = node15 && tree.getLeftMost(node15);
-        expect(minNodeBySpecificNode?.id).toBe(12);
+        const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
+        expect(getMinNodeBySpecificNode?.id).toBe(12);
 
         const subTreeSum = node15 && tree.subTreeSum(node15);
         expect(subTreeSum).toBe(70);
@@ -42,39 +34,34 @@ describe('BST Case6', () => {
         const lesserSum = tree.lesserSum(10);
         expect(lesserSum).toBe(45);
 
-        expect(node15).toBeInstanceOf(BSTNode);
-        if (node15 instanceof BSTNode) {
+        if (node15) {
             const subTreeAdd = tree.subTreeAdd(node15, 1, 'count');
             expect(subTreeAdd).toBeDefined();
         }
+        expect(node15).toBeDefined();
 
         const node11 = tree.get(11);
-        expect(node11).toBeInstanceOf(BSTNode);
         if (node11 instanceof BSTNode) {
-            const allGreaterNodesAdded = tree.allGreaterNodesAdd(node11, 2, 'count');
-            expect(allGreaterNodesAdded).toBeDefined();
+            const allGreaterNodesAdd = tree.allGreaterNodesAdd(node11, 2, 'count');
+            expect(allGreaterNodesAdd).toBeDefined();
         }
 
-        const dfsInorderNodes = tree.DFS('in', 'node');
-        expect(dfsInorderNodes[0].id).toBe(1);
-        expect(dfsInorderNodes[dfsInorderNodes.length - 1].id).toBe(16);
+        const dfs = tree.DFS('in', 'node');
+        expect(dfs[0].id).toBe(1);
+        expect(dfs[dfs.length - 1].id).toBe(16);
 
         tree.balance();
+        const bfs = tree.BFS('node');
         expect(tree.isBalanced()).toBe(true);
+        expect(bfs[0].id).toBe(8);
+        expect(bfs[bfs.length - 1].id).toBe(16);
 
-        const bfsNodesAfterBalanced = tree.BFS('node');
-        expect(bfsNodesAfterBalanced[0].id).toBe(8);
-        expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].id).toBe(16);
-
-        const removed11 = tree.remove(11, true);
+        const removed11 = tree.remove(1, true);
         expect(removed11).toBeInstanceOf(Array);
         expect(removed11[0]).toBeDefined();
         expect(removed11[0].deleted).toBeDefined();
-
-        if (removed11[0].deleted) expect(removed11[0].deleted.id).toBe(11);
-
+        if (removed11[0].deleted) expect(removed11[0].deleted.id).toBe(1);
         expect(tree.isAVLBalanced()).toBe(true);
-
         expect(node15 && tree.getHeight(node15)).toBe(2);
 
         const removed1 = tree.remove(1, true);
@@ -84,7 +71,6 @@ describe('BST Case6', () => {
         if (removed1[0].deleted) expect(removed1[0].deleted.id).toBe(1);
 
         expect(tree.isAVLBalanced()).toBe(true);
-
         expect(tree.getHeight()).toBe(4);
 
         const removed4 = tree.remove(4, true);
@@ -112,6 +98,7 @@ describe('BST Case6', () => {
         expect(tree.isAVLBalanced()).toBe(true);
         expect(tree.getHeight()).toBe(3);
 
+
         const removed5 = tree.remove(5, true);
         expect(removed5).toBeInstanceOf(Array);
         expect(removed5[0]).toBeDefined();
@@ -179,16 +166,16 @@ describe('BST Case6', () => {
         expect(tree.getHeight()).toBe(2);
 
 
-        expect(tree.isAVLBalanced()).toBe(false);
+        expect(!tree.isAVLBalanced()).toBe(true);
 
-        const bfsIDs = tree.BFS();
-        expect(bfsIDs[0]).toBe(2);
-        expect(bfsIDs[1]).toBe(12);
-        expect(bfsIDs[2]).toBe(16);
+        const lastBFSIds = tree.BFS();
+        expect(lastBFSIds[0]).toBe(2);
+        expect(lastBFSIds[1]).toBe(12);
+        expect(lastBFSIds[2]).toBe(16);
 
-        const bfsNodes = tree.BFS('node');
-        expect(bfsNodes[0].id).toBe(2);
-        expect(bfsNodes[1].id).toBe(12);
-        expect(bfsNodes[2].id).toBe(16);
+        const lastBFSNodes = tree.BFS('node');
+        expect(lastBFSNodes[0].id).toBe(2);
+        expect(lastBFSNodes[1].id).toBe(12);
+        expect(lastBFSNodes[2].id).toBe(16);
     });
 });

package/notes/note.md

@@ -0,0 +1,23 @@
+<table>
+<tbody><tr>
+<th><p>S.No</p></th>
+<th><p>add() function</p></th>
+<th><p>offer() method</p></th>
+</tr>
+<tr>
+<td><p>1</p></td>
+<td><p>add() function throws an IllegalState exception when you try to insert an element in a full queue.</p></td>
+<td><p>It does not throw any exception but returns false when the queue is full or reaches its maximum size.</p></td>
+</tr>
+<tr>
+<td><p>2</p></td>
+<td><p>On successful inserting a queue element, add() method returns true. It does not return False</p></td>
+<td><p>offer() method returns True on successfully inserting an element and returns False when it fails to insert a Queue element.</p></td>
+</tr>
+<tr>
+<td><p>3</p></td>
+<td><p>It belongs to the Collection framework.</p></td>
+<td><p>It is a queue method.</p></td>
+</tr>
+</tbody>
+</table>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.15.2",
+  "version": "1.16.1",
   "description": "Explore our comprehensive Javascript Data Structure / TypeScript Data Structure Library, meticulously crafted to empower developers with a versatile set of essential data structures. Our library includes a wide range of data structures, such as Binary Tree, AVL Tree, Binary Search Tree (BST), Tree Multiset, Segment Tree, Binary Indexed Tree, Graph, Directed Graph, Undirected Graph, Singly Linked List, Hash, CoordinateSet, CoordinateMap, Heap, Doubly Linked List, Priority Queue, Max Priority Queue, Min Priority Queue, Queue, ObjectDeque, ArrayDeque, Stack, and Trie. Each data structure is thoughtfully designed and implemented using TypeScript to provide efficient, reliable, and easy-to-use solutions for your programming needs. Whether you're optimizing algorithms, managing data, or enhancing performance, our TypeScript Data Structure Library is your go-to resource. Elevate your coding experience with these fundamental building blocks for software development.",
   "main": "dist/index.js",
   "scripts": {

package/.idea/data-structure-typed.iml

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="WEB_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <excludeFolder url="file://$MODULE_DIR$/temp" />
-      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
-      <excludeFolder url="file://$MODULE_DIR$/tmp" />
-      <excludeFolder url="file://$MODULE_DIR$/dist" />
-      <excludeFolder url="file://$MODULE_DIR$/notes" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/data-structure-typed.iml" filepath="$PROJECT_DIR$/.idea/data-structure-typed.iml" />
-    </modules>
-  </component>
-</project>

package/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>

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

@@ -1,3 +0,0 @@
-export class AaTree {
-
-}

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

@@ -1,293 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import {BST, BSTNode} from './bst';
-import type {AVLTreeDeleted, BinaryTreeNodeId} from '../types';
-
-export class AVLTreeNode<T> extends BSTNode<T> {
-    /**
-     * The function overrides the clone method of the AVLTreeNode class to create a new AVLTreeNode object with the same
-     * id, value, and count.
-     * @returns The method is returning a new instance of the AVLTreeNode class with the same id, val, and count values as
-     * the current instance.
-     */
-    override clone(): AVLTreeNode<T> {
-        return new AVLTreeNode<T>(this.id, this.val, this.count);
-    }
-}
-
-export class AVLTree<T> extends BST<T> {
-
-    override createNode(id: BinaryTreeNodeId, val: T, count?: number): AVLTreeNode<T> {
-        return new AVLTreeNode<T>(id, val, count);
-    }
-
-    /**
-     * The function overrides the add method of a Binary Search Tree to insert a node with a given id and value, and then
-     * balances the tree.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that we want to add or
-     * update in the AVL tree.
-     * @param {T | null} val - The `val` parameter represents the value that you want to assign to the node with the given
-     * `id`. It can be of type `T` (the generic type) or `null`.
-     * @param {number} [count] - The `count` parameter is an optional parameter of type `number`. It represents the number
-     * of times the value `val` should be inserted into the AVL tree. If the `count` parameter is not provided, it defaults
-     * to `1`, indicating that the value should be inserted once.
-     * @returns The method is returning either an AVLTreeNode<T> object or null.
-     */
-    override add(id: BinaryTreeNodeId, val: T | null, count?: number): AVLTreeNode<T> | null {
-        const inserted = super.add(id, val, count);
-        if (inserted) this.balancePath(inserted);
-        return inserted;
-    }
-
-    /**
-     * The function overrides the remove method of the Binary Search Tree class, performs the removal operation, and
-     * then balances the tree if necessary.
-     * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node that needs to be
-     * removed from the AVL tree.
-     * @param {boolean} [isUpdateAllLeftSum] - The `isUpdateAllLeftSum` parameter is an optional boolean parameter that
-     * determines whether the left sum of all nodes in the AVL tree should be updated after removing a node. If
-     * `isUpdateAllLeftSum` is set to `true`, the left sum of all nodes will be recalculated.
-     * @returns The method is returning an array of `AVLTreeDeleted<T>` objects.
-     */
-    override remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): AVLTreeDeleted<T>[] {
-        const deletedResults = super.remove(id, isUpdateAllLeftSum);
-        for (const {needBalanced} of deletedResults) {
-            if (needBalanced) {
-                this.balancePath(needBalanced);
-            }
-        }
-        return deletedResults;
-    }
-
-    /**
-     * The balance factor of a given AVL tree node is calculated by subtracting the height of its left subtree from the
-     * height of its right subtree.
-     * @param node - The parameter "node" is of type AVLTreeNode<T>, which represents a node in an AVL tree.
-     * @returns The balance factor of the given AVL tree node.
-     */
-    balanceFactor(node: AVLTreeNode<T>): number {
-        if (!node.right) // node has no right subtree
-            return -node.height;
-        else if (!node.left) // node has no left subtree
-            return +node.height;
-        else
-            return node.right.height - node.left.height;
-    }
-
-    /**
-     * The function updates the height of a node in an AVL tree based on the heights of its left and right subtrees.
-     * @param node - The parameter `node` is an AVLTreeNode object, which represents a node in an AVL tree.
-     */
-    updateHeight(node: AVLTreeNode<T>): void {
-        if (!node.left && !node.right) // node is a leaf
-            node.height = 0;
-        else if (!node.left) {
-            // node has no left subtree
-            const rightHeight = node.right ? node.right.height : 0;
-            node.height = 1 + rightHeight;
-        } else if (!node.right) // node has no right subtree
-            node.height = 1 + node.left.height;
-        else
-            node.height = 1 + Math.max(node.right.height, node.left.height);
-    }
-
-    /**
-     * The `balancePath` function balances the AVL tree by performing appropriate rotations based on the balance factor of
-     * each node in the path from the given node to the root.
-     * @param node - The `node` parameter is an AVLTreeNode object, which represents a node in an AVL tree.
-     */
-    balancePath(node: AVLTreeNode<T>): void {
-        const path = this.getPathToRoot(node);
-        for (let i = path.length - 1; i >= 0; i--) {
-            const A = path[i];
-            this.updateHeight(A);
-            switch (this.balanceFactor(A)) {
-                case -2:
-                    if (A && A.left) {
-                        if (this.balanceFactor(A.left) <= 0) {
-                            this.balanceLL(A); // Perform LL rotation
-                        } else {
-                            this.balanceLR(A); // Perform LR rotation
-                        }
-                    }
-                    break;
-                case +2:
-                    if (A && A.right) {
-                        if (this.balanceFactor(A.right) >= 0) {
-                            this.balanceRR(A); // Perform RR rotation
-                        } else {
-                            this.balanceRL(A); // Perform RL rotation
-                        }
-                    }
-            }
-        }
-    }
-
-    /**
-     * The `balanceLL` function performs a left-left rotation on an AVL tree to balance it.
-     * @param A - The parameter A is an AVLTreeNode object.
-     */
-    balanceLL(A: AVLTreeNode<T>): void {
-        const parentOfA = A.parent;
-        const B = A.left; // A is left-heavy and B is left-heavy
-        A.parent = B;
-        if (B && B.right) {
-            B.right.parent = A;
-        }
-        if (B) B.parent = parentOfA;
-        if (A === this.root) {
-            if (B) this.root = B;
-        } else {
-            if (parentOfA?.left === A) {
-                parentOfA.left = B;
-            } else {
-                if (parentOfA) parentOfA.right = B;
-            }
-        }
-
-        if (B) {
-            A.left = B.right; // Make T2 the left subtree of A
-            B.right = A; // Make A the left child of B
-        }
-        this.updateHeight(A);
-        if (B) this.updateHeight(B);
-    }
-
-    /**
-     * The `balanceLR` function performs a left-right rotation to balance an AVL tree.
-     * @param A - A is an AVLTreeNode object.
-     */
-    balanceLR(A: AVLTreeNode<T>): void {
-        const parentOfA = A.parent;
-        const B = A.left; // A is left-heavy
-        let C = null;
-        if (B) {
-            C = B.right;// B is right-heavy
-        }
-        if (A) A.parent = C;
-        if (B) B.parent = C;
-
-        if (C) {
-            if (C.left) {
-                C.left.parent = B;
-            }
-            if (C.right) {
-                C.right.parent = A;
-            }
-            C.parent = parentOfA;
-        }
-
-        if (A === this.root) {
-            if (C) this.root = C;
-        } else {
-            if (parentOfA) {
-                if (parentOfA.left === A) {
-                    parentOfA.left = C;
-                } else {
-                    parentOfA.right = C;
-                }
-            }
-        }
-
-        if (C) {
-            A.left = C.right; // Make T3 the left subtree of A
-            if (B) B.right = C.left; // Make T2 the right subtree of B
-            C.left = B;
-            C.right = A;
-        }
-
-        this.updateHeight(A); // Adjust heights
-        B && this.updateHeight(B);
-        C && this.updateHeight(C);
-    }
-
-    /**
-     * The `balanceRR` function performs a right-right rotation on an AVL tree to balance it.
-     * @param A - The parameter A is an AVLTreeNode object.
-     */
-    balanceRR(A: AVLTreeNode<T>): void {
-        const parentOfA = A.parent;
-        const B = A.right; // A is right-heavy and B is right-heavy
-        A.parent = B;
-        if (B) {
-            if (B.left) {
-                B.left.parent = A;
-            }
-            B.parent = parentOfA;
-        }
-
-        if (A === this.root) {
-            if (B) this.root = B;
-        } else {
-            if (parentOfA) {
-                if (parentOfA.left === A) {
-                    parentOfA.left = B;
-                } else {
-                    parentOfA.right = B;
-                }
-            }
-        }
-
-        if (B) {
-            A.right = B.left; // Make T2 the right subtree of A
-            B.left = A;
-        }
-        this.updateHeight(A);
-        B && this.updateHeight(B);
-    }
-
-    /**
-     * The `balanceRL` function performs a right-left rotation to balance an AVL tree.
-     * @param A - A is an AVLTreeNode object.
-     */
-    balanceRL(A: AVLTreeNode<T>): void {
-        const parentOfA = A.parent;
-        const B = A.right; // A is right-heavy
-        let C = null;
-        if (B) {
-            C = B.left; // B is left-heavy
-        }
-
-        A.parent = C;
-        if (B) B.parent = C;
-
-        if (C) {
-            if (C.left) {
-                C.left.parent = A;
-            }
-            if (C.right) {
-                C.right.parent = B;
-            }
-            C.parent = parentOfA;
-        }
-
-
-        if (A === this.root) {
-            if (C) this.root = C;
-        } else {
-            if (parentOfA) {
-                if (parentOfA.left === A) {
-                    parentOfA.left = C;
-                } else {
-                    parentOfA.right = C;
-                }
-            }
-        }
-
-        if (C) A.right = C.left; // Make T2 the right subtree of A
-        if (B && C) B.left = C.right; // Make T3 the left subtree of B
-        if (C) C.left = A;
-        if (C) C.right = B;
-
-        this.updateHeight(A); // Adjust heights
-        B && this.updateHeight(B);
-        C && this.updateHeight(C);
-    }
-}
-
-

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

@@ -1,3 +0,0 @@
-export class BTree {
-
-}

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

@@ -1,69 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export class BinaryIndexedTree {
-    private readonly _sumTree: number[];
-
-    /**
-     * The constructor initializes an array with a specified length and fills it with zeros.
-     * @param {number} n - The parameter `n` represents the size of the array that will be used to store the sum tree. The
-     * sum tree is a binary tree data structure used to efficiently calculate the sum of a range of elements in an array.
-     * The size of the sum tree array is `n + 1` because
-     */
-    constructor(n: number) {
-        this._sumTree = new Array<number>(n + 1).fill(0);
-    }
-
-    static lowBit(x: number) {
-        return x & (-x);
-    }
-
-    /**
-     * The update function updates the values in a binary indexed tree by adding a delta value to the specified index and
-     * its ancestors.
-     * @param {number} i - The parameter `i` represents the index of the element in the `_sumTree` array that needs to be
-     * updated.
-     * @param {number} delta - The "delta" parameter represents the change in value that needs to be added to the element
-     * at index "i" in the "_sumTree" array.
-     */
-    update(i: number, delta: number) {
-        while (i < this._sumTree.length) {
-            this._sumTree[i] += delta;
-            i += BinaryIndexedTree.lowBit(i);
-        }
-    }
-
-    /**
-     * The function calculates the prefix sum of an array using a binary indexed tree.
-     * @param {number} i - The parameter "i" in the function "getPrefixSum" represents the index of the element in the
-     * array for which we want to calculate the prefix sum.
-     * @returns The function `getPrefixSum` returns the prefix sum of the elements in the binary indexed tree up to index
-     * `i`.
-     */
-    getPrefixSum(i: number) {
-        let sum = 0;
-        while (i > 0) {
-            sum += this._sumTree[i];
-            i -= BinaryIndexedTree.lowBit(i);
-        }
-        return sum;
-    }
-
-    /**
-     * The function `getRangeSum` calculates the sum of a range of numbers in an array.
-     * @param {number} start - The start parameter is the starting index of the range for which we want to calculate the
-     * sum.
-     * @param {number} end - The "end" parameter represents the ending index of the range for which we want to calculate
-     * the sum.
-     * @returns the sum of the elements in the range specified by the start and end indices.
-     */
-    public getRangeSum(start: number, end: number): number {
-        if (!(0 <= start && start <= end && end <= this._sumTree.length))
-            throw 'Index out of bounds';
-        return this.getPrefixSum(end) - this.getPrefixSum(start);
-    }
-}