graph-typed 1.39.5 → 1.40.0

package/dist/data-structures/stack/stack.js

@@ -16,6 +16,9 @@ class Stack {
     constructor(elements) {
         this._elements = Array.isArray(elements) ? elements : [];
     }
+    get elements() {
+        return this._elements;
+    }
     /**
      * The function "fromArray" creates a new Stack object from an array of elements.
      * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.
@@ -30,14 +33,14 @@ class Stack {
      * @returns A boolean value indicating whether the `_elements` array is empty or not.
      */
     isEmpty() {
-        return this._elements.length === 0;
+        return this.elements.length === 0;
     }
     /**
      * The size() function returns the number of elements in an array.
      * @returns The size of the elements array.
      */
     size() {
-        return this._elements.length;
+        return this.elements.length;
     }
     /**
      * The `peek` function returns the last element of an array, or null if the array is empty.
@@ -46,7 +49,7 @@ class Stack {
     peek() {
         if (this.isEmpty())
             return null;
-        return this._elements[this._elements.length - 1];
+        return this.elements[this.elements.length - 1];
     }
     /**
      * The push function adds an element to the stack and returns the updated stack.
@@ -54,7 +57,7 @@ class Stack {
      * @returns The `push` method is returning the updated `Stack<E>` object.
      */
     push(element) {
-        this._elements.push(element);
+        this.elements.push(element);
         return this;
     }
     /**
@@ -65,14 +68,14 @@ class Stack {
     pop() {
         if (this.isEmpty())
             return null;
-        return this._elements.pop() || null;
+        return this.elements.pop() || null;
     }
     /**
      * The toArray function returns a copy of the elements in an array.
      * @returns An array of type E.
      */
     toArray() {
-        return this._elements.slice();
+        return this.elements.slice();
     }
     /**
      * The clear function clears the elements array.
@@ -85,7 +88,7 @@ class Stack {
      * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
      */
     clone() {
-        return new Stack(this._elements.slice());
+        return new Stack(this.elements.slice());
     }
 }
 exports.Stack = Stack;

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

@@ -1,14 +1,8 @@
 export declare class TreeNode<V = any> {
+    key: string;
+    value?: V | undefined;
+    children?: TreeNode<V>[] | undefined;
     constructor(key: string, value?: V, children?: TreeNode<V>[]);
-    private _key;
-    get key(): string;
-    set key(value: string);
-    private _value?;
-    get value(): V | undefined;
-    set value(value: V | undefined);
-    private _children?;
-    get children(): TreeNode<V>[] | undefined;
-    set children(value: TreeNode<V>[] | undefined);
     addChildren(children: TreeNode<V> | TreeNode<V>[]): void;
     getHeight(): number;
 }

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

@@ -3,27 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeNode = void 0;
 class TreeNode {
     constructor(key, value, children) {
-        this._key = key;
-        this._value = value || undefined;
-        this._children = children || [];
-    }
-    get key() {
-        return this._key;
-    }
-    set key(value) {
-        this._key = value;
-    }
-    get value() {
-        return this._value;
-    }
-    set value(value) {
-        this._value = value;
-    }
-    get children() {
-        return this._children;
-    }
-    set children(value) {
-        this._children = value;
+        this.key = key;
+        this.value = value || undefined;
+        this.children = children || [];
     }
     addChildren(children) {
         if (!this.children) {

package/dist/data-structures/trie/trie.d.ts

@@ -10,26 +10,20 @@
  * and a flag indicating whether it's the end of a word.
  */
 export declare class TrieNode {
+    key: string;
+    children: Map<string, TrieNode>;
+    isEnd: boolean;
     constructor(key: string);
-    private _key;
-    get key(): string;
-    set key(v: string);
-    protected _children: Map<string, TrieNode>;
-    get children(): Map<string, TrieNode>;
-    set children(v: Map<string, TrieNode>);
-    protected _isEnd: boolean;
-    get isEnd(): boolean;
-    set isEnd(v: boolean);
 }
 /**
  * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
  */
 export declare class Trie {
-    private readonly _caseSensitive;
     constructor(words?: string[], caseSensitive?: boolean);
+    protected _caseSensitive: boolean;
+    get caseSensitive(): boolean;
     protected _root: TrieNode;
     get root(): TrieNode;
-    set root(v: TrieNode);
     /**
      * Add a word to the Trie structure.
      * @param {string} word - The word to add.
@@ -81,5 +75,5 @@ export declare class Trie {
      * @returns {string[]} an array of strings.
      */
     getWords(prefix?: string, max?: number, isAllWhenEmptyPrefix?: boolean): string[];
-    private _caseProcess;
+    protected _caseProcess(str: string): string;
 }

package/dist/data-structures/trie/trie.js

@@ -14,27 +14,9 @@ exports.Trie = exports.TrieNode = void 0;
  */
 class TrieNode {
     constructor(key) {
-        this._key = key;
-        this._isEnd = false;
-        this._children = new Map();
-    }
-    get key() {
-        return this._key;
-    }
-    set key(v) {
-        this._key = v;
-    }
-    get children() {
-        return this._children;
-    }
-    set children(v) {
-        this._children = v;
-    }
-    get isEnd() {
-        return this._isEnd;
-    }
-    set isEnd(v) {
-        this._isEnd = v;
+        this.key = key;
+        this.isEnd = false;
+        this.children = new Map();
     }
 }
 exports.TrieNode = TrieNode;
@@ -51,12 +33,12 @@ class Trie {
             }
         }
     }
+    get caseSensitive() {
+        return this._caseSensitive;
+    }
     get root() {
         return this._root;
     }
-    set root(v) {
-        this._root = v;
-    }
     /**
      * Add a word to the Trie structure.
      * @param {string} word - The word to add.

package/dist/interfaces/binary-tree.d.ts

@@ -1,7 +1,7 @@
 import { BinaryTreeNode } from '../data-structures';
-import { BinaryTreeDeletedResult, BTNKey, BinaryTreeNodeNested, BTNCallback } from '../types';
+import { BinaryTreeDeletedResult, BinaryTreeNodeNested, BTNCallback, BTNKey } from '../types';
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>> {
-    createNode(key: BTNKey, val?: N['val']): N;
-    add(keyOrNode: BTNKey | N | null, val?: N['val']): N | null | undefined;
+    createNode(key: BTNKey, value?: N['value']): N;
+    add(keyOrNode: BTNKey | N | null, value?: N['value']): N | null | undefined;
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeletedResult<N>[];
 }

package/dist/interfaces/graph.d.ts

@@ -1,5 +1,5 @@
 import { VertexKey } from '../types';
 export interface IGraph<V, E, VO, EO> {
-    createVertex(key: VertexKey, val?: V): VO;
-    createEdge(srcOrV1: VertexKey | string, destOrV2: VertexKey | string, weight?: number, val?: E): EO;
+    createVertex(key: VertexKey, value?: V): VO;
+    createEdge(srcOrV1: VertexKey, destOrV2: VertexKey, weight?: number, value?: E): EO;
 }

package/dist/types/data-structures/binary-tree/bst.d.ts

@@ -1,5 +1,5 @@
 import { BSTNode } from '../../../data-structures';
-import type { BTNKey, BinaryTreeOptions } from './binary-tree';
+import type { BinaryTreeOptions, BTNKey } from './binary-tree';
 export type BSTComparator = (a: BTNKey, b: BTNKey) => number;
 export type BSTNodeNested<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BSTOptions = BinaryTreeOptions & {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graph-typed",
-  "version": "1.39.5",
+  "version": "1.40.0",
   "description": "Graph. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -135,6 +135,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.39.5"
+    "data-structure-typed": "^1.40.0"
   }
 }

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

@@ -13,16 +13,15 @@ import {IBinaryTree} from '../../interfaces';
 export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNested<V>> extends BSTNode<V, N> {
   height: number;
 
-  constructor(key: BTNKey, val?: V) {
-    super(key, val);
+  constructor(key: BTNKey, value?: V) {
+    super(key, value);
     this.height = 0;
   }
 }
 
 export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTreeNodeNested<V>>>
   extends BST<V, N>
-  implements IBinaryTree<V, N>
-{
+  implements IBinaryTree<V, N> {
   /**
    * This is a constructor function for an AVL tree data structure in TypeScript.
    * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
@@ -37,13 +36,13 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
    * 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
    * the new node. It is used to determine the position of the node in the binary search tree.
-   * @param [val] - The parameter `val` 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 `val` property of the
+   * @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.
    */
-  override createNode(key: BTNKey, val?: V): N {
-    return new AVLTreeNode<V, N>(key, val) as N;
+  override createNode(key: BTNKey, value?: V): N {
+    return new AVLTreeNode<V, N>(key, value) as N;
   }
 
   /**
@@ -51,13 +50,12 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
    * a new node.
    * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can accept either a
    * `BTNKey` or a `N` (which represents a node in the binary tree) or `null`.
-   * @param [val] - The `val` parameter is the value that you want to assign to the new node that you
+   * @param [value] - The `value` parameter is the value that you want to assign to the new node that you
    * are adding to the binary search tree.
    * @returns The method is returning the inserted node (`N`), `null`, or `undefined`.
    */
-  override add(keyOrNode: BTNKey | N | null, val?: V): N | null | undefined {
-    // TODO support node as a param
-    const inserted = super.add(keyOrNode, val);
+  override add(keyOrNode: BTNKey | N | null, value?: V): N | null | undefined {
+    const inserted = super.add(keyOrNode, value);
     if (inserted) this._balancePath(inserted);
     return inserted;
   }
@@ -97,18 +95,18 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
    * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
    */
   protected override _swap(srcNode: N, destNode: N): N {
-    const {key, val, height} = destNode;
-    const tempNode = this.createNode(key, val);
+    const {key, value, height} = destNode;
+    const tempNode = this.createNode(key, value);
 
     if (tempNode) {
       tempNode.height = height;
 
       destNode.key = srcNode.key;
-      destNode.val = srcNode.val;
+      destNode.value = srcNode.value;
       destNode.height = srcNode.height;
 
       srcNode.key = tempNode.key;
-      srcNode.val = tempNode.val;
+      srcNode.value = tempNode.value;
       srcNode.height = tempNode.height;
     }
 
@@ -162,7 +160,7 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
       // Balance Restoration: If a balance issue is discovered after inserting a node, it requires balance restoration operations. Balance restoration includes four basic cases where rotation operations need to be performed to fix the balance:
       switch (
         this._balanceFactor(A) // second O(1)
-      ) {
+        ) {
         case -2:
           if (A && A.left) {
             if (this._balanceFactor(A.left) <= 0) {

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

@@ -17,7 +17,7 @@ export class BinaryIndexedTree {
    * @param  - - `frequency`: The default frequency value. It is optional and has a default
    * value of 0.
    */
-  constructor({frequency = 0, max}: {frequency?: number; max: number}) {
+  constructor({frequency = 0, max}: { frequency?: number; max: number }) {
     this._freq = frequency;
     this._max = max;
     this._freqMap = {0: 0};
@@ -31,30 +31,18 @@ export class BinaryIndexedTree {
     return this._freqMap;
   }
 
-  set freqMap(value: Record<number, number>) {
-    this._freqMap = value;
-  }
-
   protected _msb: number;
 
   get msb(): number {
     return this._msb;
   }
 
-  set msb(value: number) {
-    this._msb = value;
-  }
-
   protected _negativeCount: number;
 
   get negativeCount(): number {
     return this._negativeCount;
   }
 
-  set negativeCount(value: number) {
-    this._negativeCount = value;
-  }
-
   get freq(): number {
     return this._freq;
   }
@@ -232,9 +220,9 @@ export class BinaryIndexedTree {
    */
   protected _updateNegativeCount(freqCur: number, freqNew: number): void {
     if (freqCur < 0 && freqNew >= 0) {
-      this.negativeCount--;
+      this._negativeCount--;
     } else if (freqCur >= 0 && freqNew < 0) {
-      this.negativeCount++;
+      this._negativeCount++;
     }
   }
 

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

@@ -26,7 +26,7 @@ export class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = BinaryTree
   /**
    * The value stored in the node.
    */
-  val: V | undefined;
+  value: V | undefined;
 
   /**
    * The parent node of the current node.
@@ -36,14 +36,14 @@ export class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = BinaryTree
   /**
    * Creates a new instance of BinaryTreeNode.
    * @param {BTNKey} key - The key associated with the node.
-   * @param {V} val - The value stored in the node.
+   * @param {V} value - The value stored in the node.
    */
-  constructor(key: BTNKey, val?: V) {
+  constructor(key: BTNKey, value?: V) {
     this.key = key;
-    this.val = val;
+    this.value = value;
   }
 
-  private _left: N | null | undefined;
+  protected _left: N | null | undefined;
 
   /**
    * Get the left child node.
@@ -63,7 +63,7 @@ export class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = BinaryTree
     this._left = v;
   }
 
-  private _right: N | null | undefined;
+  protected _right: N | null | undefined;
 
   /**
    * Get the right child node.
@@ -108,8 +108,9 @@ export class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = BinaryTree
  * @template N - The type of the binary tree's nodes.
  */
 export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>>
-  implements IBinaryTree<V, N>
-{
+  implements IBinaryTree<V, N> {
+  iterationType: IterationType = IterationType.ITERATIVE;
+
   /**
    * Creates a new instance of BinaryTree.
    * @param {BinaryTreeOptions} [options] - The options for the binary tree.
@@ -117,28 +118,11 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
   constructor(options?: BinaryTreeOptions) {
     if (options !== undefined) {
       const {iterationType = IterationType.ITERATIVE} = options;
-      this._iterationType = iterationType;
+      this.iterationType = iterationType;
     }
   }
 
-  private _iterationType: IterationType = IterationType.ITERATIVE;
-
-  /**
-   * Get the iteration type used in the binary tree.
-   */
-  get iterationType(): IterationType {
-    return this._iterationType;
-  }
-
-  /**
-   * Set the iteration type for the binary tree.
-   * @param {IterationType} v - The new iteration type to set.
-   */
-  set iterationType(v: IterationType) {
-    this._iterationType = v;
-  }
-
-  private _root: N | null = null;
+  protected _root: N | null = null;
 
   /**
    * Get the root node of the binary tree.
@@ -147,7 +131,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return this._root;
   }
 
-  private _size = 0;
+  protected _size = 0;
 
   /**
    * Get the number of nodes in the binary tree.
@@ -159,18 +143,18 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
   /**
    * Creates a new instance of BinaryTreeNode with the given key and value.
    * @param {BTNKey} key - The key for the new node.
-   * @param {V} val - The value for the new node.
+   * @param {V} value - The value for the new node.
    * @returns {N} - The newly created BinaryTreeNode.
    */
-  createNode(key: BTNKey, val?: V): N {
-    return new BinaryTreeNode<V, N>(key, val) as N;
+  createNode(key: BTNKey, value?: V): N {
+    return new BinaryTreeNode<V, N>(key, value) as N;
   }
 
   /**
    * Clear the binary tree, removing all nodes.
    */
   clear() {
-    this._root = null;
+    this._setRoot(null);
     this._size = 0;
   }
 
@@ -185,10 +169,10 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
   /**
    * Add a node with the given key and value to the binary tree.
    * @param {BTNKey | N | null} keyOrNode - The key or node to add to the binary tree.
-   * @param {V} val - The value for the new node (optional).
+   * @param {V} value - The value for the new node (optional).
    * @returns {N | null | undefined} - The inserted node, or null if nothing was inserted, or undefined if the operation failed.
    */
-  add(keyOrNode: BTNKey | N | null, val?: V): N | null | undefined {
+  add(keyOrNode: BTNKey | N | null, value?: V): N | null | undefined {
     const _bfs = (root: N, newNode: N | null): N | undefined | null => {
       const queue = new Queue<N | null>([root]);
       while (queue.size > 0) {
@@ -209,7 +193,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     if (keyOrNode === null) {
       needInsert = null;
     } else if (typeof keyOrNode === 'number') {
-      needInsert = this.createNode(keyOrNode, val);
+      needInsert = this.createNode(keyOrNode, value);
     } else if (keyOrNode instanceof BinaryTreeNode) {
       needInsert = keyOrNode;
     } else {
@@ -221,7 +205,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
 
     if (this.root) {
       if (existNode) {
-        existNode.val = val;
+        existNode.value = value;
         inserted = existNode;
       } else {
         inserted = _bfs(this.root, needInsert);
@@ -229,9 +213,9 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     } else {
       this._setRoot(needInsert);
       if (needInsert !== null) {
-        this._setSize(1);
+        this._size = 1;
       } else {
-        this._setSize(0);
+        this._size = 0;
       }
       inserted = this.root;
     }
@@ -252,15 +236,15 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     // TODO not sure addMany not be run multi times
     return keysOrNodes.map((keyOrNode, i) => {
       if (keyOrNode instanceof BinaryTreeNode) {
-        return this.add(keyOrNode.key, keyOrNode.val);
+        return this.add(keyOrNode.key, keyOrNode.value);
       }
 
       if (keyOrNode === null) {
         return this.add(null);
       }
 
-      const val = values?.[i];
-      return this.add(keyOrNode, val);
+      const value = values?.[i];
+      return this.add(keyOrNode, value);
     });
   }
 
@@ -339,7 +323,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         }
       }
     }
-    this._setSize(this.size - 1);
+    this._size = this.size - 1;
 
     bstDeletedResult.push({deleted: orgCurrent, needBalanced});
     return bstDeletedResult;
@@ -401,7 +385,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         return -1;
       }
 
-      const stack: {node: N; depth: number}[] = [{node: beginRoot, depth: 0}];
+      const stack: { node: N; depth: number }[] = [{node: beginRoot, depth: 0}];
       let maxHeight = 0;
 
       while (stack.length > 0) {
@@ -904,7 +888,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
       _traverse(beginRoot);
     } else {
       // 0: visit, 1: print
-      const stack: {opt: 0 | 1; node: N | null | undefined}[] = [{opt: 0, node: beginRoot}];
+      const stack: { opt: 0 | 1; node: N | null | undefined }[] = [{opt: 0, node: beginRoot}];
 
       while (stack.length > 0) {
         const cur = stack.pop();
@@ -1174,7 +1158,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The `*[Symbol.iterator]` method returns a generator object that yields the keys of the
    * binary tree nodes in a specific order.
    */
-  *[Symbol.iterator](node = this.root): Generator<BTNKey, void, undefined> {
+  * [Symbol.iterator](node = this.root): Generator<BTNKey, void, undefined> {
     if (!node) {
       return;
     }
@@ -1212,15 +1196,15 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns {N} - The destination node after the swap.
    */
   protected _swap(srcNode: N, destNode: N): N {
-    const {key, val} = destNode;
-    const tempNode = this.createNode(key, val);
+    const {key, value} = destNode;
+    const tempNode = this.createNode(key, value);
 
     if (tempNode) {
       destNode.key = srcNode.key;
-      destNode.val = srcNode.val;
+      destNode.value = srcNode.value;
 
       srcNode.key = tempNode.key;
-      srcNode.val = tempNode.val;
+      srcNode.value = tempNode.value;
     }
 
     return destNode;
@@ -1244,13 +1228,13 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
       if (parent.left === undefined) {
         parent.left = newNode;
         if (newNode) {
-          this._setSize(this.size + 1);
+          this._size = this.size + 1;
         }
         return parent.left;
       } else if (parent.right === undefined) {
         parent.right = newNode;
         if (newNode) {
-          this._setSize(this.size + 1);
+          this._size = this.size + 1;
         }
         return parent.right;
       } else {
@@ -1274,14 +1258,5 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     this._root = v;
   }
 
-  /**
-   * The function sets the value of the protected property "_size" to the given number.
-   * @param {number} v - The parameter "v" is a number that represents the size value that we want to
-   * set.
-   */
-  protected _setSize(v: number) {
-    this._size = v;
-  }
-
   // --- end additional methods ---
 }