directed-graph-typed 1.48.0 → 1.49.0

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

@@ -29,7 +29,7 @@ exports.AVLTreeNode = AVLTreeNode;
 class AVLTree extends bst_1.BST {
     /**
      * The constructor function initializes an AVLTree object with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<K, V, N>`
      * objects. It represents a collection of elements that will be added to the AVL tree during
      * initialization.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
@@ -43,7 +43,7 @@ class AVLTree extends bst_1.BST {
     }
     /**
      * The function creates a new AVL tree node with the specified key and value.
-     * @param {BTNKey} key - The key parameter is the key value that will be associated with
+     * @param {K} key - The key parameter is the key value that will be associated with
      * the new node. It is used to determine the position of the node in the binary search tree.
      * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It is of
      * type `V`, which means it can be any value that is assignable to the `value` property of the
@@ -61,16 +61,25 @@ class AVLTree extends bst_1.BST {
      * @returns a new AVLTree object.
      */
     createTree(options) {
-        return new AVLTree([], Object.assign({ iterationType: this.iterationType, comparator: this.comparator }, options));
+        return new AVLTree([], Object.assign({ iterationType: this.iterationType, variant: this.variant }, options));
     }
     /**
      * The function checks if an exemplar is an instance of AVLTreeNode.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the AVLTreeNode class.
      */
     isNode(exemplar) {
         return exemplar instanceof AVLTreeNode;
     }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof AVLTreeNode);
+    }
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -81,14 +90,16 @@ class AVLTree extends bst_1.BST {
      *
      * The function overrides the add method of a binary tree node and balances the tree after inserting
      * a new node.
-     * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be either a key, a node, or an
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
      * entry.
-     * @returns The method is returning either the inserted node or `undefined`.
+     * @param {V} [value] - The `value` parameter represents the value associated with the key that is
+     * being added to the binary tree.
+     * @returns The method is returning either the inserted node or undefined.
      */
-    add(keyOrNodeOrEntry) {
+    add(keyOrNodeOrEntry, value) {
         if (keyOrNodeOrEntry === null)
             return undefined;
-        const inserted = super.add(keyOrNodeOrEntry);
+        const inserted = super.add(keyOrNodeOrEntry, value);
         if (inserted)
             this._balancePath(inserted);
         return inserted;
@@ -126,9 +137,9 @@ class AVLTree extends bst_1.BST {
     /**
      * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a binary
      * tree.
-     * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node that
-     * needs to be swapped with the destination node. It can be of type `BTNKey`, `N`, or `undefined`.
-     * @param {BTNKey | N  | undefined} destNode - The `destNode` parameter represents the destination
+     * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node that
+     * needs to be swapped with the destination node. It can be of type `K`, `N`, or `undefined`.
+     * @param {K | N  | undefined} destNode - The `destNode` parameter represents the destination
      * node where the values from the source node will be swapped to.
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.