data-structure-typed 0.8.18 → 1.12.9

package/README.md

@@ -1,2 +1,298 @@
-# data-structure-ts
-Hash (CoordinateSet, CoordinateMap) Heap (MaxHeap, MinHeap) Binary Tree (AVL Tree, Binary Indexed Tree, Binary Search Tree, Segment Tree, Tree Multiset) Graph (Directed Graph, Undirected Graph) Linked List (Singly Linked List, Doubly Linked List) Matrix Priority Queue (Max Priority Queue, Min Priority Queue) Queue (Queue, Dequeue) Stack Trie
+# data-structure-typed
+
+Javascript Data Structure, TypeScript Data Structure Library
+
+## install
+
+### yarn
+
+```bash
+yarn add data-structure-typed
+```
+
+### npm
+
+```bash
+npm install data-structure-typed
+```
+
+## api docs
+
+[//]: # ([api docs](https://data-structure-typed-docs.vercel.app/))
+
+<nav class="tsd-navigation"><a href="https://data-structure-typed-docs.vercel.app/modules.html" class="current"><span>data-<wbr/>structure-<wbr/>typed</span></a>
+<ul class="tsd-small-nested-navigation">
+
+[//]: # (<li><a href="https://data-structure-typed-docs.vercel.app/enums/CP.html"><span>CP</span></a></li>)
+
+[//]: # (<li><a href="https://data-structure-typed-docs.vercel.app/enums/FamilyPosition.html"><span>Family<wbr/>Position</span></a></li>)
+
+[//]: # (<li><a href="https://data-structure-typed-docs.vercel.app/enums/LoopType.html"><span>Loop<wbr/>Type</span></a></li>)
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/AVLTree.html"><span>AVLTree</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/AVLTreeNode.html"><span>AVLTree<wbr/>Node</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/AaTree.html"><span>Aa<wbr/>Tree</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/AbstractEdge.html"><span>Abstract<wbr/>Edge</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/AbstractGraph.html"><span>Abstract<wbr/>Graph</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/AbstractVertex.html"><span>Abstract<wbr/>Vertex</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/ArrayDeque.html"><span>Array<wbr/>Deque</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/BST.html"><span>BST</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/BSTNode.html"><span>BSTNode</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/BTree.html"><span>BTree</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/BinaryIndexedTree.html"><span>Binary<wbr/>Indexed<wbr/>Tree</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/BinaryTree.html"><span>Binary<wbr/>Tree</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/BinaryTreeNode.html"><span>Binary<wbr/>Tree<wbr/>Node</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/Character.html"><span>Character</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/CoordinateMap.html"><span>Coordinate<wbr/>Map</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/CoordinateSet.html"><span>Coordinate<wbr/>Set</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/Deque.html"><span>Deque</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/DirectedEdge.html"><span>Directed<wbr/>Edge</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/DirectedGraph.html"><span>Directed<wbr/>Graph</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/DirectedVertex.html"><span>Directed<wbr/>Vertex</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/DoublyLinkedList.html"><span>Doubly<wbr/>Linked<wbr/>List</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/DoublyLinkedListNode.html"><span>Doubly<wbr/>Linked<wbr/>List<wbr/>Node</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/Heap.html"><span>Heap</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/Matrix2D.html"><span>Matrix2D</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/MatrixNTI2D.html"><span>MatrixNTI2D</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/MaxHeap.html"><span>Max<wbr/>Heap</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/MaxPriorityQueue.html"><span>Max<wbr/>Priority<wbr/>Queue</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/MinHeap.html"><span>Min<wbr/>Heap</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/MinPriorityQueue.html"><span>Min<wbr/>Priority<wbr/>Queue</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/Navigator.html"><span>Navigator</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/ObjectDeque.html"><span>Object<wbr/>Deque</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/PriorityQueue.html"><span>Priority<wbr/>Queue</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/Queue.html"><span>Queue</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/RBTree.html"><span>RBTree</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/SegmentTree.html"><span>Segment<wbr/>Tree</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/SegmentTreeNode.html"><span>Segment<wbr/>Tree<wbr/>Node</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/SinglyLinkedList.html"><span>Singly<wbr/>Linked<wbr/>List</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/SinglyLinkedListNode.html"><span>Singly<wbr/>Linked<wbr/>List<wbr/>Node</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/SplayTree.html"><span>Splay<wbr/>Tree</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/Stack.html"><span>Stack</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/TreeMultiSet.html"><span>Tree<wbr/>Multi<wbr/>Set</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/Trie.html"><span>Trie</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/TrieNode.html"><span>Trie<wbr/>Node</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/TwoThreeTree.html"><span>Two<wbr/>Three<wbr/>Tree</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/UndirectedEdge.html"><span>Undirected<wbr/>Edge</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/UndirectedGraph.html"><span>Undirected<wbr/>Graph</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/UndirectedVertex.html"><span>Undirected<wbr/>Vertex</span></a></li>
+<li><a href="https://data-structure-typed-docs.vercel.app/classes/Vector2D.html"><span>Vector2D</span></a></li></ul></nav>
+
+## data structures
+
+Meticulously crafted to empower developers with a versatile set of essential data structures. Our library includes a wide range of data structures:
+Binary Tree, Binary Search Tree (BST), AVL Tree, Tree Multiset, Segment Tree, Binary Indexed Tree, Graph, Directed Graph, Undirected Graph, Linked List, Singly Linked List, Doubly Linked List, Queue, Object Deque, Array Deque, Stack, Hash, Coordinate Set, Coordinate Map, Heap, Priority Queue, Max Priority Queue, Min Priority Queue, Trie
+<table>
+<thead>
+  <tr>
+    <th>Data Structure</th>
+    <th>Derived</th>
+    <th>Basic Features</th>
+    <th>Additional Features</th>
+  </tr>
+</thead>
+
+<tbody>
+<tr>
+    <td>Binary Tree</td>
+    <td>AVL Tree, Binary Search Tree, Tree Multiset</td>
+    <td>put, has, get, remove, size, insertTo, insertMany, fill, getDepth, getHeight, getMinHeight, getPathToRoot, isBalanced </td>
+    <td>getLeftMost, isBST, getSubTreeSizeAndCount, subTreeSum, subTreeAdd, BFS, DFS, DFSIterative, levelIterative, listLevels, getPredecessor, morris,  </td>
+  </tr>
+
+  <tr>
+    <td>AVL Tree</td>
+    <td></td>
+    <td>All the features inherited from Binary Tree, balanceFactor, updateHeight, balancePath, balanceLL, balanceLR, balanceRR, balanceRL</td>
+    <td></td>
+  </tr>
+
+  <tr>
+    <td>Binary Search Tree (BST)</td>
+    <td></td>
+    <td>All the features inherited from Binary Tree, lastKey</td>
+    <td>All the features inherited from Binary Tree, lesserSum, allGreaterNodesAdd, balance, isAVLBalanced</td>
+  </tr>
+
+  <tr>
+    <td>Tree Multiset</td>
+    <td></td>
+    <td>All the features inherited from Binary Tree</td>
+    <td>All the features inherited from Binary Tree</td>
+  </tr>
+
+  <tr>
+    <td>Segment Tree</td>
+    <td></td>
+    <td>build, updateNode, querySumByRange</td>
+    <td></td>
+  </tr>
+
+  <tr>
+    <td>Binary Indexed Tree</td>
+    <td></td>
+    <td>update, getPrefixSum, getRangeSum, BinaryIndexedTree.lowBit</td>
+    <td></td>
+  </tr>
+  <tr>
+    <td>Graph</td>
+    <td>Directed Graph, Undirected Graph</td>
+    <td>getVertex, getVertexId, containsVertex, vertexSet, addVertex, removeVertex, removeAllVertices, containsEdge, setEdgeWeight, getAllPathsBetween, getPathSumWeight, getMinCostBetween, getMinPathBetween, </td>
+    <td>dijkstra, dijkstraWithoutHeap, bellmanFord, floyd, tarjan</td>
+  </tr>
+  <tr>
+    <td>Directed Graph</td>
+    <td></td>
+    <td>All the features inherited from Graph, getEdge, addEdge, removeEdgeBetween, removeEdge, removeAllEdges, incomingEdgesOf, outgoingEdgesOf, degreeOf, inDegreeOf, outDegreeOf, edgesOf, getEdgeSrc, getEdgeDest, getDestinations, edgeSet, getNeighbors, getEndsOfEdge</td>
+    <td>All the features inherited from Graph, topologicalSort</td>
+  </tr>
+  <tr>
+    <td>Undirected Graph</td>
+    <td></td>
+    <td>All the features inherited from Graph, getEdge, addEdge, removeEdgeBetween, removeEdge, degreeOf, edgesOf, edgeSet, getEdgesOf, getNeighbors, getEndsOfEdge</td>
+    <td>All the features inherited from Graph</td>
+  </tr>
+  <tr>
+    <td>Singly Linked List</td>
+    <td></td>
+    <td>length, head, tail, size, get, getNode, findNodeIndex, findNode, find, findIndex, append, push, prepend, insertAt, removeNode, removeAt, insertBefore, sort, insertAfter, shift, pop, merge, clear, slice, reverse, forEach, map, filter, reduce, toArray, toString</td>
+    <td></td>
+
+  </tr>
+  <tr>
+    <td>Hash</td>
+    <td>CoordinateSet, CoordinateMap</td>
+    <td></td>
+    <td></td>
+  </tr>
+  <tr>
+    <td>CoordinateSet</td>
+    <td></td>
+    <td>has, set, get, delete</td>
+    <td></td>
+  </tr>
+  <tr>
+    <td>CoordinateMap</td>
+    <td></td>
+    <td>has, add, delete</td>
+    <td></td>
+  </tr>
+  <tr>
+    <td>Heap</td>
+    <td></td>
+    <td></td>
+  </tr>
+
+
+  <tr>
+    <td>Doubly Linked List</td>
+    <td></td>
+    <td>size, offerFirst, offerLast, peekFirst, peekLast, pollFirst, pollLast, get, isEmpty, insert, remove, </td>
+    <td></td>
+  </tr>
+
+[//]: # (  <tr>)
+
+[//]: # (    <td>Matrix</td>)
+
+[//]: # (    <td></td>)
+
+[//]: # (    <td></td>)
+
+[//]: # (    <td></td>)
+
+[//]: # (  </tr>)
+
+  <tr>
+    <td>Priority Queue</td>
+    <td>Max Priority Queue, Min Priority Queue</td>
+    <td>offer, peek, poll, leaf, isEmpty, clear, toArray, clone</td>
+    <td>isValid, sort, DFS</td>
+  </tr>
+  <tr>
+    <td>Max Priority Queue</td>
+    <td></td>
+    <td>All the features inherited from Priority Queue</td>
+    <td>All the features inherited from Priority Queue</td>
+  </tr>
+  <tr>
+    <td>Min Priority Queue</td>
+    <td></td>
+    <td>All the features inherited from Priority Queue</td>
+    <td>All the features inherited from Priority Queue</td>
+  </tr>
+  <tr>
+    <td>Queue</td>
+    <td>Queue, Dequeue</td>
+    <td>offer, poll, peek, peekLast, size, isEmpty, toArray, clear, clone, Queue.fromArray</td>
+    <td></td>
+  </tr>
+  <tr>
+    <td>ObjectDeque</td>
+    <td></td>
+    <td>size, offerFirst, offerLast, pollFirst, peekFirst, pollLast, peekLast, get, isEmpty</td>
+    <td></td>
+  </tr>
+  <tr>
+    <td>ArrayDeque</td>
+    <td></td>
+    <td>offerLast, pollLast, pollFirst, offerFirst, peekFirst, peekLast, get, set, insert, remove, isEmpty</td>
+    <td></td>
+  </tr>
+  <tr>
+    <td>Stack</td>
+    <td></td>
+    <td>isEmpty, size, peek, push, pop, toArray, clear, clone, Stack.fromArray</td>
+    <td></td>
+  </tr>
+  <tr>
+    <td>Trie</td>
+    <td></td>
+    <td>put, has, remove, isAbsPrefix, isPrefix, getAll</td>
+    <td></td>
+  </tr>
+</tbody>
+
+</table>
+
+
+
+
+![complexities](src/assets/complexities-diff.jpg)
+
+![complexities of data structures](src/assets/data-structure-complexities.jpg)
+
+![](src/data-structures/binary-tree/diagrams/bst-rotation.gif)
+
+![](src/data-structures/binary-tree/diagrams/avl-tree-inserting.gif)
+
+
+![](src/data-structures/graph/diagrams/tarjan.webp)
+
+![](src/data-structures/graph/diagrams/adjacency-list.jpg)
+
+![](src/data-structures/graph/diagrams/adjacency-list-pros-cons.jpg)
+
+![](src/data-structures/graph/diagrams/adjacency-matrix.jpg)
+
+![](src/data-structures/graph/diagrams/adjacency-matrix-pros-cons.jpg)
+
+![](src/data-structures/graph/diagrams/dfs-can-do.jpg)
+
+![](src/data-structures/graph/diagrams/edge-list.jpg)
+
+![](src/data-structures/graph/diagrams/edge-list-pros-cons.jpg)
+
+![](src/data-structures/graph/diagrams/max-flow.jpg)
+
+![](src/data-structures/graph/diagrams/mst.jpg)
+
+[//]: # (![]&#40;src/data-structures/graph/diagrams/tarjan-articulation-point-bridge.png&#41;)
+
+[//]: # (![]&#40;src/data-structures/graph/diagrams/tarjan-complicate-simple.png&#41;)
+
+[//]: # (![]&#40;src/data-structures/graph/diagrams/tarjan-strongly-connected-component.png&#41;)
+
+
+
+
+

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

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AaTree = void 0;
-class AaTree {
-}
+var AaTree = /** @class */ (function () {
+    function AaTree() {
+    }
+    return AaTree;
+}());
 exports.AaTree = AaTree;

package/dist/data-structures/binary-tree/avl-tree.d.ts

@@ -1,21 +1,74 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 import { BST, BSTNode } from './bst';
-import { BinaryTreeNodeId } from './binary-tree';
-export interface AVLTreeDeleted<T> {
-    deleted: AVLTreeNode<T> | null;
-    needBalanced: AVLTreeNode<T> | null;
-}
+import type { AVLTreeDeleted, BinaryTreeNodeId } from '../types';
 export declare class AVLTreeNode<T> extends BSTNode<T> {
     clone(): AVLTreeNode<T>;
 }
 export declare class AVLTree<T> extends BST<T> {
     createNode(id: BinaryTreeNodeId, val: T, count?: number): AVLTreeNode<T>;
+    /**
+     * The function overrides the put 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 put 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.
+     */
     put(id: BinaryTreeNodeId, val: T | null, count?: number): AVLTreeNode<T> | null;
+    /**
+     * 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.
+     */
     remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): AVLTreeDeleted<T>[];
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
 }

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

@@ -1,57 +1,144 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AVLTree = exports.AVLTreeNode = void 0;
-const bst_1 = require("./bst");
-class AVLTreeNode extends bst_1.BSTNode {
-    clone() {
-        return new AVLTreeNode(this.id, this.val, this.count);
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+var bst_1 = require("./bst");
+var AVLTreeNode = /** @class */ (function (_super) {
+    __extends(AVLTreeNode, _super);
+    function AVLTreeNode() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-}
+    AVLTreeNode.prototype.clone = function () {
+        return new AVLTreeNode(this.id, this.val, this.count);
+    };
+    return AVLTreeNode;
+}(bst_1.BSTNode));
 exports.AVLTreeNode = AVLTreeNode;
-class AVLTree extends bst_1.BST {
-    createNode(id, val, count) {
-        return new AVLTreeNode(id, val, count);
+var AVLTree = /** @class */ (function (_super) {
+    __extends(AVLTree, _super);
+    function AVLTree() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-    put(id, val, count) {
-        const inserted = super.put(id, val, count);
+    AVLTree.prototype.createNode = function (id, val, count) {
+        return new AVLTreeNode(id, val, count);
+    };
+    /**
+     * The function overrides the put 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 put 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.
+     */
+    AVLTree.prototype.put = function (id, val, count) {
+        var inserted = _super.prototype.put.call(this, id, val, count);
         if (inserted)
             this.balancePath(inserted);
         return inserted;
-    }
-    remove(id, isUpdateAllLeftSum) {
-        const deletedResults = super.remove(id, isUpdateAllLeftSum);
-        for (const { needBalanced } of deletedResults) {
-            if (needBalanced) {
-                this.balancePath(needBalanced);
+    };
+    /**
+     * 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.
+     */
+    AVLTree.prototype.remove = function (id, isUpdateAllLeftSum) {
+        var e_1, _a;
+        var deletedResults = _super.prototype.remove.call(this, id, isUpdateAllLeftSum);
+        try {
+            for (var deletedResults_1 = __values(deletedResults), deletedResults_1_1 = deletedResults_1.next(); !deletedResults_1_1.done; deletedResults_1_1 = deletedResults_1.next()) {
+                var needBalanced = deletedResults_1_1.value.needBalanced;
+                if (needBalanced) {
+                    this.balancePath(needBalanced);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (deletedResults_1_1 && !deletedResults_1_1.done && (_a = deletedResults_1.return)) _a.call(deletedResults_1);
             }
+            finally { if (e_1) throw e_1.error; }
         }
         return deletedResults;
-    }
-    balanceFactor(node) {
+    };
+    /**
+     * 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.
+     */
+    AVLTree.prototype.balanceFactor = function (node) {
         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;
-    }
-    updateHeight(node) {
+    };
+    /**
+     * 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.
+     */
+    AVLTree.prototype.updateHeight = function (node) {
         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;
+            var 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);
-    }
-    balancePath(node) {
-        const path = this.getPathToRoot(node);
-        for (let i = path.length - 1; i >= 0; i--) {
-            const A = path[i];
+    };
+    /**
+     * 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.
+     */
+    AVLTree.prototype.balancePath = function (node) {
+        var path = this.getPathToRoot(node);
+        for (var i = path.length - 1; i >= 0; i--) {
+            var A = path[i];
             this.updateHeight(A);
             switch (this.balanceFactor(A)) {
                 case -2:
@@ -75,10 +162,14 @@ class AVLTree extends bst_1.BST {
                     }
             }
         }
-    }
-    balanceLL(A) {
-        const parentOfA = A.parent;
-        const B = A.left; // A is left-heavy and B is left-heavy
+    };
+    /**
+     * The `balanceLL` function performs a left-left rotation on an AVL tree to balance it.
+     * @param A - The parameter A is an AVLTreeNode object.
+     */
+    AVLTree.prototype.balanceLL = function (A) {
+        var parentOfA = A.parent;
+        var B = A.left; // A is left-heavy and B is left-heavy
         A.parent = B;
         if (B && B.right) {
             B.right.parent = A;
@@ -105,11 +196,15 @@ class AVLTree extends bst_1.BST {
         this.updateHeight(A);
         if (B)
             this.updateHeight(B);
-    }
-    balanceLR(A) {
-        const parentOfA = A.parent;
-        const B = A.left; // A is left-heavy
-        let C = null;
+    };
+    /**
+     * The `balanceLR` function performs a left-right rotation to balance an AVL tree.
+     * @param A - A is an AVLTreeNode object.
+     */
+    AVLTree.prototype.balanceLR = function (A) {
+        var parentOfA = A.parent;
+        var B = A.left; // A is left-heavy
+        var C = null;
         if (B) {
             C = B.right; // B is right-heavy
         }
@@ -150,10 +245,14 @@ class AVLTree extends bst_1.BST {
         this.updateHeight(A); // Adjust heights
         B && this.updateHeight(B);
         C && this.updateHeight(C);
-    }
-    balanceRR(A) {
-        const parentOfA = A.parent;
-        const B = A.right; // A is right-heavy and B is right-heavy
+    };
+    /**
+     * The `balanceRR` function performs a right-right rotation on an AVL tree to balance it.
+     * @param A - The parameter A is an AVLTreeNode object.
+     */
+    AVLTree.prototype.balanceRR = function (A) {
+        var parentOfA = A.parent;
+        var B = A.right; // A is right-heavy and B is right-heavy
         A.parent = B;
         if (B) {
             if (B.left) {
@@ -181,11 +280,15 @@ class AVLTree extends bst_1.BST {
         }
         this.updateHeight(A);
         B && this.updateHeight(B);
-    }
-    balanceRL(A) {
-        const parentOfA = A.parent;
-        const B = A.right; // A is right-heavy
-        let C = null;
+    };
+    /**
+     * The `balanceRL` function performs a right-left rotation to balance an AVL tree.
+     * @param A - A is an AVLTreeNode object.
+     */
+    AVLTree.prototype.balanceRL = function (A) {
+        var parentOfA = A.parent;
+        var B = A.right; // A is right-heavy
+        var C = null;
         if (B) {
             C = B.left; // B is left-heavy
         }
@@ -226,6 +329,7 @@ class AVLTree extends bst_1.BST {
         this.updateHeight(A); // Adjust heights
         B && this.updateHeight(B);
         C && this.updateHeight(C);
-    }
-}
+    };
+    return AVLTree;
+}(bst_1.BST));
 exports.AVLTree = AVLTree;