linked-list-typed 1.51.5 → 1.51.8

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

@@ -14,12 +14,14 @@ import type {
   BinaryTreePrintOptions,
   BTNCallback,
   BTNEntry,
+  Comparable,
   DFSOrderPattern,
   EntryCallback,
+  FamilyPosition,
+  IterationType,
   KeyOrNodeOrEntry,
   NodeDisplayLayout
 } from '../../types';
-import { FamilyPosition, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { trampoline } from '../../utils';
 import { Queue } from '../queue';
@@ -31,7 +33,7 @@ import { IterableEntryBase } from '../base';
  * @template NODE - The type of the family relationship in the binary tree.
  */
 export class BinaryTreeNode<
-  K = any,
+  K extends Comparable,
   V = any,
   NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>
 > {
@@ -129,7 +131,7 @@ export class BinaryTreeNode<
  */
 
 export class BinaryTree<
-  K = any,
+  K extends Comparable,
   V = any,
   NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>,
   TREE extends BinaryTree<K, V, NODE, TREE> = BinaryTree<K, V, NODE, BinaryTreeNested<K, V, NODE>>
@@ -147,12 +149,11 @@ export class BinaryTree<
    * `Partial<BinaryTreeOptions>`, which means that not all properties of `BinaryTreeOptions` are
    * required.
    */
-  constructor(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, NODE>> = [], options?: BinaryTreeOptions<K>) {
+  constructor(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, NODE>> = [], options?: BinaryTreeOptions) {
     super();
     if (options) {
-      const { iterationType, extractor } = options;
+      const { iterationType } = options;
       if (iterationType) this.iterationType = iterationType;
-      if (extractor) this._extractor = extractor;
     }
 
     this._size = 0;
@@ -160,16 +161,6 @@ export class BinaryTree<
     if (keysOrNodesOrEntries) this.addMany(keysOrNodesOrEntries);
   }
 
-  protected _extractor = (key: K) => (typeof key === 'number' ? key : Number(key));
-
-  /**
-   * The function returns the value of the `_extractor` property.
-   * @returns The `_extractor` property is being returned.
-   */
-  get extractor() {
-    return this._extractor;
-  }
-
   protected _root?: NODE | null;
 
   /**
@@ -218,7 +209,7 @@ export class BinaryTree<
    * you can provide only a subset of the properties defined in the `BinaryTreeOptions` interface.
    * @returns a new instance of a binary tree.
    */
-  createTree(options?: Partial<BinaryTreeOptions<K>>): TREE {
+  createTree(options?: Partial<BinaryTreeOptions>): TREE {
     return new BinaryTree<K, V, NODE, TREE>([], { iterationType: this.iterationType, ...options }) as TREE;
   }
 
@@ -278,17 +269,19 @@ export class BinaryTree<
     keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
     iterationType: IterationType = 'ITERATIVE'
   ): NODE | null | undefined {
+    if (keyOrNodeOrEntry === this.NIL) return;
     if (this.isRealNode(keyOrNodeOrEntry)) {
       return keyOrNodeOrEntry;
-    } else if (this.isEntry(keyOrNodeOrEntry)) {
-      if (keyOrNodeOrEntry[0] === null) return null;
-      if (keyOrNodeOrEntry[0] === undefined) return;
-      return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
-    } else {
-      if (keyOrNodeOrEntry === null) return null;
-      if (keyOrNodeOrEntry === undefined) return;
-      return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
     }
+    if (this.isEntry(keyOrNodeOrEntry)) {
+      const key = keyOrNodeOrEntry[0];
+      if (key === null) return null;
+      if (key === undefined) return;
+      return this.getNodeByKey(key, iterationType);
+    }
+    if (keyOrNodeOrEntry === null) return null;
+    if (keyOrNodeOrEntry === undefined) return;
+    return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
   }
 
   /**
@@ -506,8 +499,7 @@ export class BinaryTree<
   ): BinaryTreeDeleteResult<NODE>[] {
     const deletedResult: BinaryTreeDeleteResult<NODE>[] = [];
     if (!this.root) return deletedResult;
-    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
-      callback = (node => node) as C;
+    callback = this._ensureCallback(identifier, callback);
 
     const curr = this.getNode(identifier, callback);
     if (!curr) return deletedResult;
@@ -610,10 +602,9 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): NODE[] {
-    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
-      callback = (node => node) as C;
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return [];
+    callback = this._ensureCallback(identifier, callback);
 
     const ans: NODE[] = [];
 
@@ -722,29 +713,8 @@ export class BinaryTree<
    * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
    * found in the binary tree. If no node is found, it returns `undefined`.
    */
-  getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | undefined {
-    if (!this.root) return undefined;
-    if (iterationType === 'RECURSIVE') {
-      const dfs = (cur: NODE): NODE | undefined => {
-        if (cur.key === key) return cur;
-
-        if (!cur.left && !cur.right) return;
-        if (cur.left) return dfs(cur.left);
-        if (cur.right) return dfs(cur.right);
-      };
-
-      return dfs(this.root);
-    } else {
-      const stack = [this.root];
-      while (stack.length > 0) {
-        const cur = stack.pop();
-        if (cur) {
-          if (cur.key === key) return cur;
-          cur.left && stack.push(cur.left);
-          cur.right && stack.push(cur.right);
-        }
-      }
-    }
+  getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | null | undefined {
+    return this.getNode(key, this._DEFAULT_CALLBACK, this.root, iterationType);
   }
 
   override get<C extends BTNCallback<NODE, K>>(
@@ -801,7 +771,7 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): V | undefined {
-    return this.getNode(identifier, callback, beginRoot, iterationType)?.value ?? undefined;
+    return this.getNode(identifier, callback, beginRoot, iterationType)?.value;
   }
 
   override has<C extends BTNCallback<NODE, K>>(
@@ -857,8 +827,7 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): boolean {
-    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
-      callback = (node => node) as C;
+    callback = this._ensureCallback(identifier, callback);
 
     return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
   }
@@ -943,7 +912,7 @@ export class BinaryTree<
     if (iterationType === 'RECURSIVE') {
       const dfs = (cur: NODE | null | undefined, min: number, max: number): boolean => {
         if (!this.isRealNode(cur)) return true;
-        const numKey = this.extractor(cur.key);
+        const numKey = Number(cur.key);
         if (numKey <= min || numKey >= max) return false;
         return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
       };
@@ -963,7 +932,7 @@ export class BinaryTree<
             curr = curr.left;
           }
           curr = stack.pop()!;
-          const numKey = this.extractor(curr.key);
+          const numKey = Number(curr.key);
           if (!this.isRealNode(curr) || (!checkMax && prev >= numKey) || (checkMax && prev <= numKey)) return false;
           prev = numKey;
           curr = curr.right;
@@ -995,15 +964,15 @@ export class BinaryTree<
    * @returns the depth of the `dist` relative to the `beginRoot`.
    */
   getDepth(dist: KeyOrNodeOrEntry<K, V, NODE>, beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root): number {
-    dist = this.ensureNode(dist);
-    beginRoot = this.ensureNode(beginRoot);
+    let distEnsured = this.ensureNode(dist);
+    const beginRootEnsured = this.ensureNode(beginRoot);
     let depth = 0;
-    while (dist?.parent) {
-      if (dist === beginRoot) {
+    while (distEnsured?.parent) {
+      if (distEnsured === beginRootEnsured) {
         return depth;
       }
       depth++;
-      dist = dist.parent;
+      distEnsured = distEnsured.parent;
     }
     return depth;
   }
@@ -1146,17 +1115,17 @@ export class BinaryTree<
   getPathToRoot(beginNode: KeyOrNodeOrEntry<K, V, NODE>, isReverse = true): NODE[] {
     // TODO to support get path through passing key
     const result: NODE[] = [];
-    beginNode = this.ensureNode(beginNode);
+    let beginNodeEnsured = this.ensureNode(beginNode);
 
-    if (!beginNode) return result;
+    if (!beginNodeEnsured) return result;
 
-    while (beginNode.parent) {
+    while (beginNodeEnsured.parent) {
       // Array.push + Array.reverse is more efficient than Array.unshift
       // TODO may consider using Deque, so far this is not the performance bottleneck
-      result.push(beginNode);
-      beginNode = beginNode.parent;
+      result.push(beginNodeEnsured);
+      beginNodeEnsured = beginNodeEnsured.parent;
     }
-    result.push(beginNode);
+    result.push(beginNodeEnsured);
     return isReverse ? result.reverse() : result;
   }
 
@@ -1862,10 +1831,10 @@ export class BinaryTree<
       console.log(`U for undefined
       `);
     if (opts.isShowNull)
-      console.log(`NODE for null
+      console.log(`N for null
       `);
     if (opts.isShowRedBlackNIL)
-      console.log(`S for Sentinel Node
+      console.log(`S for Sentinel Node(NIL)
       `);
 
     const display = (root: NODE | null | undefined): void => {
@@ -1895,24 +1864,24 @@ export class BinaryTree<
       let current: NODE | null | undefined = node;
 
       while (current || stack.length > 0) {
-        while (current && !isNaN(this.extractor(current.key))) {
+        while (this.isRealNode(current)) {
           stack.push(current);
           current = current.left;
         }
 
         current = stack.pop();
 
-        if (current && !isNaN(this.extractor(current.key))) {
+        if (this.isRealNode(current)) {
           yield [current.key, current.value];
           current = current.right;
         }
       }
     } else {
-      if (node.left && !isNaN(this.extractor(node.key))) {
+      if (node.left && this.isRealNode(node)) {
         yield* this[Symbol.iterator](node.left);
       }
       yield [node.key, node.value];
-      if (node.right && !isNaN(this.extractor(node.key))) {
+      if (node.right && this.isRealNode(node)) {
         yield* this[Symbol.iterator](node.right);
       }
     }
@@ -1941,13 +1910,13 @@ export class BinaryTree<
       return emptyDisplayLayout;
     } else if (node === undefined && !isShowUndefined) {
       return emptyDisplayLayout;
-    } else if (node !== null && node !== undefined && isNaN(this.extractor(node.key)) && !isShowRedBlackNIL) {
+    } else if (this.isNIL(node) && !isShowRedBlackNIL) {
       return emptyDisplayLayout;
     } else if (node !== null && node !== undefined) {
       // Display logic of normal nodes
 
       const key = node.key,
-        line = isNaN(this.extractor(key)) ? 'S' : this.extractor(key).toString(),
+        line = this.isNIL(node) ? 'S' : key.toString(),
         width = line.length;
 
       return _buildNodeDisplay(
@@ -2070,4 +2039,15 @@ export class BinaryTree<
     }
     this._root = v;
   }
+
+  protected _ensureCallback<C extends BTNCallback<NODE>>(
+    identifier: ReturnType<C> | null | undefined,
+    callback: C = this._DEFAULT_CALLBACK as C
+  ): C {
+    if ((!callback || callback === this._DEFAULT_CALLBACK) && this.isNode(identifier)) {
+      callback = (node => node) as C;
+    }
+
+    return callback;
+  }
 }