directed-graph-typed 1.39.6 → 1.41.0

package/dist/types/data-structures/binary-tree/rb-tree.js

@@ -1,8 +1,13 @@
 "use strict";
+// import {BinaryTreeOptions} from './binary-tree';
+// import {RBTreeNode} from '../../../data-structures';
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RBColor = void 0;
-var RBColor;
-(function (RBColor) {
-    RBColor["RED"] = "RED";
-    RBColor["BLACK"] = "BLACK";
-})(RBColor = exports.RBColor || (exports.RBColor = {}));
+exports.RBTNColor = void 0;
+var RBTNColor;
+(function (RBTNColor) {
+    RBTNColor[RBTNColor["RED"] = 1] = "RED";
+    RBTNColor[RBTNColor["BLACK"] = 0] = "BLACK";
+})(RBTNColor = exports.RBTNColor || (exports.RBTNColor = {}));
+// export type RBTreeNodeNested<T> = RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+//
+// export type RBTreeOptions = BinaryTreeOptions & {}

package/package.json

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

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

@@ -21,8 +21,7 @@ export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNeste
 
 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
@@ -56,7 +55,6 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
    * @returns The method is returning the inserted node (`N`), `null`, or `undefined`.
    */
   override add(keyOrNode: BTNKey | N | null, value?: V): N | null | undefined {
-    // TODO support node as a param
     const inserted = super.add(keyOrNode, value);
     if (inserted) this._balancePath(inserted);
     return inserted;
@@ -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

@@ -43,7 +43,7 @@ export class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = BinaryTree
     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.
@@ -170,7 +154,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * Clear the binary tree, removing all nodes.
    */
   clear() {
-    this._root = null;
+    this._setRoot(null);
     this._size = 0;
   }
 
@@ -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;
     }
@@ -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();
@@ -966,7 +950,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     if (iterationType === IterationType.RECURSIVE) {
       const queue = new Queue<N>([beginRoot]);
 
-      function traverse(level: number) {
+      const traverse = (level: number) => {
         if (queue.size === 0) return;
 
         const current = queue.shift()!;
@@ -1064,6 +1048,26 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     }
   }
 
+  /**
+   * The function `getSuccessor` returns the next node in a binary tree given a node `x`, or `null` if
+   * `x` is the last node.
+   * @param {N} x - N - a node in a binary tree
+   * @returns The function `getSuccessor` returns a value of type `N` (the successor node), or `null`
+   * if there is no successor, or `undefined` if the input `x` is `undefined`.
+   */
+  getSuccessor(x: N): N | null | undefined{
+    if (x.right) {
+      return this.getLeftMost(x.right);
+    }
+
+    let y: N | null | undefined = x.parent;
+    while (y && y && x === y.right) {
+      x = y;
+      y = y.parent;
+    }
+    return y;
+  }
+
   // --- start additional methods ---
 
   /**
@@ -1174,7 +1178,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;
     }
@@ -1196,10 +1200,12 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
       }
     } else {
       if (node.left) {
+        // @ts-ignore
         yield* this[Symbol.iterator](node.left);
       }
       yield node.key;
       if (node.right) {
+        // @ts-ignore
         yield* this[Symbol.iterator](node.right);
       }
     }
@@ -1244,13 +1250,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 +1280,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 ---
 }

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {BTNKey, BSTComparator, BSTNodeNested, BSTOptions, BTNCallback} from '../../types';
+import type {BSTComparator, BSTNodeNested, BSTOptions, BTNCallback, BTNKey} from '../../types';
 import {CP, IterationType} from '../../types';
 import {BinaryTree, BinaryTreeNode} from './binary-tree';
 import {IBinaryTree} from '../../interfaces';
@@ -19,8 +19,7 @@ export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extend
 
 export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>>
   extends BinaryTree<V, N>
-  implements IBinaryTree<V, N>
-{
+  implements IBinaryTree<V, N> {
   /**
    * The constructor function initializes a binary search tree object with an optional comparator
    * function.
@@ -72,7 +71,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     }
     if (this.root === null) {
       this._setRoot(newNode);
-      this._setSize(this.size + 1);
+      this._size = this.size + 1;
       inserted = this.root;
     } else {
       let cur = this.root;
@@ -94,7 +93,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
               }
               //Add to the left of the current node
               cur.left = newNode;
-              this._setSize(this.size + 1);
+              this._size = this.size + 1;
               traversing = false;
               inserted = cur.left;
             } else {
@@ -109,7 +108,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
               }
               //Add to the right of the current node
               cur.right = newNode;
-              this._setSize(this.size + 1);
+              this._size = this.size + 1;
               traversing = false;
               inserted = cur.right;
             } else {
@@ -128,7 +127,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
   /**
    * The `addMany` function is used to efficiently add multiple nodes to a binary search tree while
    * maintaining balance.
-   * @param {[BTNKey | N, N['value']][]} keysOrNodes - The `arr` parameter in the `addMany` function
+   * @param {[BTNKey | N, V][]} keysOrNodes - The `arr` parameter in the `addMany` function
    * represents an array of keys or nodes that need to be added to the binary search tree. It can be an
    * array of `BTNKey` or `N` (which represents the node type in the binary search tree) or
    * `null
@@ -154,15 +153,15 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
       return super.addMany(keysOrNodes, data);
     }
     const inserted: (N | null | undefined)[] = [];
-    const combinedArr: [BTNKey | N, N['value']][] = keysOrNodes.map((value, index) => [value, data?.[index]]);
+    const combinedArr: [BTNKey | N, V][] = keysOrNodes.map((value:(BTNKey | N), index) => [value, data?.[index]] as [BTNKey | N, V]);
     let sorted = [];
 
-    function isNodeOrNullTuple(arr: [BTNKey | N, N['value']][]): arr is [N, N['value']][] {
+    function isNodeOrNullTuple(arr: [BTNKey | N, V][]): arr is [N, V][] {
       for (const [keyOrNode] of arr) if (keyOrNode instanceof BSTNode) return true;
       return false;
     }
 
-    function isBinaryTreeKeyOrNullTuple(arr: [BTNKey | N, N['value']][]): arr is [BTNKey, N['value']][] {
+    function isBinaryTreeKeyOrNullTuple(arr: [BTNKey | N, V][]): arr is [BTNKey, V][] {
       for (const [keyOrNode] of arr) if (typeof keyOrNode === 'number') return true;
       return false;
     }