red-black-tree-typed 1.48.2 → 1.48.4

package/README.md

@@ -39,37 +39,34 @@ yarn add red-black-tree-typed
 #### TS
 
 ```typescript
-import {RedBlackTree, RedBlackTreeNode} from 'data-structure-typed';
+import {RedBlackTree} from 'data-structure-typed';
 // /* or if you prefer */ import {RedBlackTree} from 'red-black-tree-typed';
 
-const rbTree = new RedBlackTree<RedBlackTreeNode<number>>();
+const rbTree = new RedBlackTree<number>();
 
 const idsOrVals = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-rbTree.addMany(idsOrVals, idsOrVals);
+rbTree.addMany(idsOrVals);
 
-const node6 = rbTree.get(6);
+const node6 = rbTree.getNode(6);
 node6 && rbTree.getHeight(node6)           // 3
 node6 && rbTree.getDepth(node6)            // 1
-const getNodeById = rbTree.get(10, 'id');
+const getNodeById = rbTree.getNodeByKey(10);
 getNodeById?.id                             // 10
 
 const getMinNodeByRoot = rbTree.getLeftMost();
 getMinNodeByRoot?.id                        // 1
 
-const node15 = rbTree.get(15);
+const node15 = rbTree.getNodeByKey(15);
 const getMinNodeBySpecificNode = node15 && rbTree.getLeftMost(node15);
 getMinNodeBySpecificNode?.id                // 12
 
-const subTreeSum = node15 && rbTree.subTreeSum(node15);
-subTreeSum                                  // 70
-
 const lesserSum = rbTree.lesserSum(10);
 lesserSum                                   // 45
 
-const node11 = rbTree.get(11);
+const node11 = rbTree.getNodeByKey(11);
 node11?.id                                  // 11
 
-const dfs = rbTree.dfs('in', 'node');
+const dfs = rbTree.dfs('in');
 dfs[0].id                                   // 1 
 rbTree.perfectlyBalance();
 const bfs = rbTree.bfs('node');
@@ -146,7 +143,7 @@ const rbTree = new RedBlackTree();
 const idsOrVals = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
 rbTree.addMany(idsOrVals, idsOrVals);
 
-const node6 = rbTree.get(6);
+const node6 = rbTree.getNodeByKey(6);
 node6 && rbTree.getHeight(node6)           // 3
 node6 && rbTree.getDepth(node6)            // 1
 const getNodeById = rbTree.get(10, 'id');
@@ -155,23 +152,17 @@ getNodeById?.id                             // 10
 const getMinNodeByRoot = rbTree.getLeftMost();
 getMinNodeByRoot?.id                        // 1
 
-const node15 = rbTree.get(15);
+const node15 = rbTree.getNodeByKey(15);
 const getMinNodeBySpecificNode = node15 && rbTree.getLeftMost(node15);
 getMinNodeBySpecificNode?.id                // 12
 
-const subTreeSum = node15 && rbTree.subTreeSum(node15);
-subTreeSum                                  // 70
-
-const lesserSum = rbTree.lesserSum(10);
-lesserSum                                   // 45
-
-const node11 = rbTree.get(11);
+const node11 = rbTree.getNodeByKey(11);
 node11?.id                                  // 11
 
-const dfs = rbTree.DFS('in', 'node');
+const dfs = rbTree.dfs('in');
 dfs[0].id                                   // 1 
 rbTree.perfectlyBalance();
-const bfs = rbTree.BFS('node');
+const bfs = rbTree.bfs('node');
 rbTree.isPerfectlyBalanced() && bfs[0].id  // 8 
 
 rbTree.delete(11, true)[0].deleted?.id     // 11
@@ -227,10 +218,10 @@ rbTree.isAVLBalanced();                    // true
 rbTree.getHeight()                         // 1
 
 rbTree.isAVLBalanced();                    // true
-const lastBFSIds = rbTree.BFS();
+const lastBFSIds = rbTree.bfs();
 lastBFSIds[0]                               // 12 
 
-const lastBFSNodes = rbTree.BFS('node');
+const lastBFSNodes = rbTree.bfs('node');
 lastBFSNodes[0].id                          // 12
 ```
 

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

@@ -6,12 +6,12 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BiTreeDeleteResult, BSTNodeKeyOrNode, BTNKey, BTNodeExemplar } from '../../types';
+import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BiTreeDeleteResult, BSTNodeKeyOrNode, BTNodeExemplar } from '../../types';
 import { BTNCallback } from '../../types';
 import { IBinaryTree } from '../../interfaces';
-export declare class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNested<V>> extends BSTNode<V, N> {
+export declare class AVLTreeNode<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeNodeNested<K, V>> extends BSTNode<K, V, N> {
     height: number;
-    constructor(key: BTNKey, value?: V);
+    constructor(key: K, value?: V);
 }
 /**
  * 1. Height-Balanced: Each node's left and right subtrees differ in height by no more than one.
@@ -23,27 +23,27 @@ export declare class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeN
  * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
  * 8. Memory Overhead: Stores balance factors (or heights) at each node, leading to slightly higher memory usage compared to a regular BST.
  */
-export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTreeNodeNested<V>>, TREE extends AVLTree<V, N, TREE> = AVLTree<V, N, AVLTreeNested<V, N>>> extends BST<V, N, TREE> implements IBinaryTree<V, N, TREE> {
+export declare class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>, TREE extends AVLTree<K, V, N, TREE> = AVLTree<K, V, N, AVLTreeNested<K, V, N>>> extends BST<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
     /**
      * 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
      * behavior of the AVL tree. It is of type `Partial<AVLTreeOptions>`, which means that you can
      * provide only a subset of the properties defined in the `AVLTreeOptions` interface.
      */
-    constructor(elements?: Iterable<BTNodeExemplar<V, N>>, options?: Partial<AVLTreeOptions>);
+    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<AVLTreeOptions<K>>);
     /**
      * 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
      * node type `N`.
      * @returns a new AVLTreeNode object with the specified key and value.
      */
-    createNode(key: BTNKey, value?: V): N;
+    createNode(key: K, value?: V): N;
     /**
      * The function creates a new AVL tree with the specified options and returns it.
      * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be
@@ -51,13 +51,13 @@ export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<
      * being created.
      * @returns a new AVLTree object.
      */
-    createTree(options?: AVLTreeOptions): TREE;
+    createTree(options?: AVLTreeOptions<K>): TREE;
     /**
      * 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: BTNodeExemplar<V, N>): exemplar is N;
+    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
     /**
      * 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.
@@ -72,7 +72,7 @@ export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<
      * entry.
      * @returns The method is returning either the inserted node or `undefined`.
      */
-    add(keyOrNodeOrEntry: BTNodeExemplar<V, N>): N | undefined;
+    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>): N | undefined;
     /**
      * 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.
@@ -96,14 +96,14 @@ export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<
     /**
      * 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.
      */
-    protected _swapProperties(srcNode: BSTNodeKeyOrNode<N>, destNode: BSTNodeKeyOrNode<N>): N | undefined;
+    protected _swapProperties(srcNode: BSTNodeKeyOrNode<K, N>, destNode: BSTNodeKeyOrNode<K, N>): N | undefined;
     /**
      * Time Complexity: O(1) - constant time, as it performs a fixed number of operations.
      * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.

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,11 +61,11 @@ 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) {
@@ -126,9 +126,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.