data-structure-typed 2.1.0 → 2.1.2

package/src/data-structures/heap/heap.ts

@@ -190,7 +190,7 @@ import { IterableElementBase } from '../base';
  *     ]);
  *     console.log(scheduleTasks(tasks, 2)); // expectedMap
  */
-export class Heap<E = unknown, R = never> extends IterableElementBase<E, R> {
+export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
   protected _equals: (a: E, b: E) => boolean = Object.is;
 
   /**
@@ -255,7 +255,7 @@ export class Heap<E = unknown, R = never> extends IterableElementBase<E, R> {
    * @returns A new heap instance of this class.
    */
 
-  static from<T, R = never, S extends Heap<T, R> = Heap<T, R>>(
+  static from<T, R = any, S extends Heap<T, R> = Heap<T, R>>(
     this: new (elements?: Iterable<T | R>, options?: HeapOptions<T, R>) => S,
     elements?: Iterable<T | R>,
     options?: HeapOptions<T, R>
@@ -273,7 +273,7 @@ export class Heap<E = unknown, R = never> extends IterableElementBase<E, R> {
    * @returns A new Heap built from elements.
    */
 
-  static heapify<EE = unknown, RR = never>(elements: Iterable<EE>, options: HeapOptions<EE, RR>): Heap<EE, RR> {
+  static heapify<EE = any, RR = any>(elements: Iterable<EE>, options: HeapOptions<EE, RR>): Heap<EE, RR> {
     return new Heap<EE, RR>(elements, options);
   }
 
@@ -788,7 +788,7 @@ export class FibonacciHeap<E> {
    */
 
   push(element: E): this {
-    const node = this._createNode(element);
+    const node = this.createNode(element);
     node.left = node;
     node.right = node;
     this.mergeWithRoot(node);
@@ -900,7 +900,7 @@ export class FibonacciHeap<E> {
     heapToMerge.clear();
   }
 
-  _createNode(element: E): FibonacciHeapNode<E> {
+  createNode(element: E): FibonacciHeapNode<E> {
     return new FibonacciHeapNode<E>(element);
   }
 

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -781,7 +781,7 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
    * @returns A new SinglyLinkedListNode instance.
    */
 
-  protected _createNode(value: E): SinglyLinkedListNode<E> {
+  protected createNode(value: E): SinglyLinkedListNode<E> {
     return new SinglyLinkedListNode<E>(value);
   }
 
@@ -807,7 +807,7 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
 
   protected _ensureNode(elementOrNode: E | SinglyLinkedListNode<E>) {
     if (this.isNode(elementOrNode)) return elementOrNode;
-    return this._createNode(elementOrNode);
+    return this.createNode(elementOrNode);
   }
 
   /**

package/src/interfaces/binary-tree.ts

@@ -18,7 +18,7 @@ import type {
  * K = key, V = value, R = raw/record used with toEntryFn (optional).
  * Transforming methods like `map` use method-level generics MK/MV/MR.
  */
-export interface IBinaryTree<K = any, V = any, R extends object = object> {
+export interface IBinaryTree<K = any, V = any, R = any> {
   // ---- state ----
   readonly size: number;
   readonly root: BinaryTreeNode<K, V> | null | undefined;
@@ -32,7 +32,7 @@ export interface IBinaryTree<K = any, V = any, R extends object = object> {
   readonly isDuplicate: boolean;
 
   // ---- construction / mutation ----
-  _createNode(key: K, value?: BinaryTreeNode<K, V>['value']): BinaryTreeNode<K, V>;
+  createNode(key: K, value?: BinaryTreeNode<K, V>['value']): BinaryTreeNode<K, V>;
 
   createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): IBinaryTree<K, V, R>;
 
@@ -232,7 +232,7 @@ export interface IBinaryTree<K = any, V = any, R extends object = object> {
 
   filter(predicate: EntryCallback<K, V | undefined, boolean>, thisArg?: unknown): this;
 
-  map<MK = K, MV = V, MR extends object = object>(
+  map<MK = K, MV = V, MR = any>(
     callback: EntryCallback<K, V | undefined, [MK, MV]>,
     options?: Partial<BinaryTreeOptions<MK, MV, MR>>,
     thisArg?: unknown

package/test/integration/all-in-one.test.ts

@@ -45,7 +45,7 @@ describe('AVL Tree Test from data-structure-typed', () => {
 
     expect(tree.delete(11)[0].deleted?.key).toBe(11);
     expect(tree.isAVLBalanced()).toBe(true);
-    expect(node15 && tree.getHeight(node15)).toBe(2);
+    expect(node15 && tree.getHeight(node15)).toBe(1);
 
     expect(tree.delete(1)[0].deleted?.key).toBe(1);
     expect(tree.isAVLBalanced()).toBe(true);

package/test/integration/compile.test.mjs

@@ -0,0 +1,159 @@
+import {
+  AVLTree,
+  BinaryTree,
+  BST,
+  Deque,
+  DoublyLinkedList,
+  HashMap,
+  Heap,
+  MaxPriorityQueue,
+  MinHeap,
+  MinPriorityQueue,
+  Queue,
+  RedBlackTree,
+  SinglyLinkedList,
+  Stack,
+  TreeMultiMap,
+  Trie
+} from 'data-structure-typed';
+
+describe('', () => {
+  it('', () => {
+    const orgArr = [6, 1, 2, 7, 5, 3, 4, 9, 8];
+    const orgStrArr = ['trie', 'trial', 'trick', 'trip', 'tree', 'trend', 'triangle', 'track', 'trace', 'transmit'];
+    const entries = [
+      [6, '6'],
+      [1, '1'],
+      [2, '2'],
+      [7, '7'],
+      [5, '5'],
+      [3, '3'],
+      [4, '4'],
+      [9, '9'],
+      [8, '8']
+    ];
+    const queue = new Queue(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const deque = new Deque(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const sList = new SinglyLinkedList(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const dList = new DoublyLinkedList(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const stack = new Stack(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const minHeap = new MinHeap(orgArr);
+
+    // [1, 5, 2, 7, 6, 3, 4, 9, 8]
+    const maxPQ = new MaxPriorityQueue(orgArr);
+
+    // [9, 8, 4, 7, 5, 2, 3, 1, 6]
+    const biTree = new BinaryTree(entries);
+
+    //         ___6___
+    //        /       \
+    //     ___1_     _2_
+    //    /     \   /   \
+    //   _7_    5   3   4
+    //  /   \
+    //  9   8
+    const bst = new BST(entries);
+
+    //     _____5___
+    //    /         \
+    //   _2_       _7_
+    //  /   \     /   \
+    //  1   3_    6   8_
+    //        \         \
+    //        4         9
+    const rbTree = new RedBlackTree(entries);
+
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+    const avl = new AVLTree(entries);
+
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+    const treeMulti = new TreeMultiMap(entries);
+
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+    const hm = new HashMap(entries);
+
+    // [[6, "6"], [1, "1"], [2, "2"], [7, "7"], [5, "5"], [3, "3"], [4, "4"], [9, "9"], [8, "8"]]
+    const rbTreeH = new RedBlackTree(hm);
+
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+    const pq = new MinPriorityQueue(orgArr);
+
+    // [1, 5, 2, 7, 6, 3, 4, 9, 8]
+    const bst1 = new BST(pq);
+
+    //     _____5___
+    //    /         \
+    //   _2_       _7_
+    //  /   \     /   \
+    //  1   3_    6   8_
+    //        \         \
+    //        4         9
+    const dq1 = new Deque(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const rbTree1 = new RedBlackTree(dq1);
+
+    //    _____5___
+    //   /         \
+    //  _2___     _7___
+    // /     \   /     \
+    // 1    _4   6    _9
+    //      /         /
+    //      3         8
+    const trie2 = new Trie(orgStrArr);
+
+    // ['trie', 'trial', 'triangle', 'trick', 'trip', 'tree', 'trend', 'track', 'trace', 'transmit']
+    const heap2 = new Heap(trie2, { comparator: (a, b) => Number(a) - Number(b) });
+
+    // ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle']
+    const dq2 = new Deque(heap2);
+
+    // ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle']
+    const entries2 = dq2.map((el, i) => [i, el]);
+    const avl2 = new AVLTree(entries2);
+    avl2.print();
+    //     ___3_______
+    //    /           \
+    //   _1_       ___7_
+    //  /   \     /     \
+    //  0   2    _5_    8_
+    //          /   \     \
+    //          4   6     9
+
+    expect(avl2.size).toBe(10);
+  });
+});

package/test/integration/compile.test.ts

@@ -0,0 +1,176 @@
+import {
+  AVLTree,
+  BinaryTree,
+  BST,
+  Deque,
+  DoublyLinkedList,
+  HashMap,
+  Heap,
+  MaxPriorityQueue,
+  MinHeap,
+  MinPriorityQueue,
+  Queue,
+  RedBlackTree,
+  SinglyLinkedList,
+  Stack,
+  TreeMultiMap,
+  Trie
+} from 'data-structure-typed';
+
+describe('compile', () => {
+  it('compiles an empty array', () => {
+    const orgArr = [6, 1, 2, 7, 5, 3, 4, 9, 8];
+    const orgStrArr = ['trie', 'trial', 'trick', 'trip', 'tree', 'trend', 'triangle', 'track', 'trace', 'transmit'];
+    const entries: [number, string][] = [
+      [6, '6'],
+      [1, '1'],
+      [2, '2'],
+      [7, '7'],
+      [5, '5'],
+      [3, '3'],
+      [4, '4'],
+      [9, '9'],
+      [8, '8']
+    ];
+
+    const queue = new Queue(orgArr);
+    queue.print();
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+
+    const deque = new Deque(orgArr);
+    deque.print();
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+
+    const sList = new SinglyLinkedList(orgArr);
+    sList.print();
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+
+    const dList = new DoublyLinkedList(orgArr);
+    dList.print();
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+
+    const stack = new Stack(orgArr);
+    stack.print();
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+
+    const minHeap = new MinHeap(orgArr);
+    minHeap.print();
+    // [1, 5, 2, 7, 6, 3, 4, 9, 8]
+
+    const maxPQ = new MaxPriorityQueue(orgArr);
+    maxPQ.print();
+    // [9, 8, 4, 7, 5, 2, 3, 1, 6]
+
+    const biTree = new BinaryTree(entries);
+    biTree.print();
+    //         ___6___
+    //        /       \
+    //     ___1_     _2_
+    //    /     \   /   \
+    //   _7_    5   3   4
+    //  /   \
+    //  9   8
+
+    const bst = new BST(entries);
+    bst.print();
+    //     _____5___
+    //    /         \
+    //   _2_       _7_
+    //  /   \     /   \
+    //  1   3_    6   8_
+    //        \         \
+    //        4         9
+
+    const rbTree = new RedBlackTree(entries);
+    rbTree.print();
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+
+    const avl = new AVLTree(entries);
+    avl.print();
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+
+    const treeMulti = new TreeMultiMap(entries);
+    treeMulti.print();
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+
+    const hm = new HashMap(entries);
+    hm.print();
+    // [[6, "6"], [1, "1"], [2, "2"], [7, "7"], [5, "5"], [3, "3"], [4, "4"], [9, "9"], [8, "8"]]
+
+    const rbTreeH = new RedBlackTree(hm);
+    rbTreeH.print();
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+
+    const pq = new MinPriorityQueue(orgArr);
+    pq.print();
+    // [1, 5, 2, 7, 6, 3, 4, 9, 8]
+
+    const bst1 = new BST(pq);
+    bst1.print();
+    //     _____5___
+    //    /         \
+    //   _2_       _7_
+    //  /   \     /   \
+    //  1   3_    6   8_
+    //        \         \
+    //        4         9
+
+    const dq1 = new Deque(orgArr);
+    dq1.print();
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const rbTree1 = new RedBlackTree(dq1);
+    rbTree1.print();
+    //    _____5___
+    //   /         \
+    //  _2___     _7___
+    // /     \   /     \
+    // 1    _4   6    _9
+    //      /         /
+    //      3         8
+
+    const trie2 = new Trie(orgStrArr);
+    trie2.print();
+    // ['trie', 'trial', 'triangle', 'trick', 'trip', 'tree', 'trend', 'track', 'trace', 'transmit']
+    const heap2 = new Heap(trie2, { comparator: (a, b) => Number(a) - Number(b) });
+    heap2.print();
+    // ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle']
+    const dq2 = new Deque(heap2);
+    dq2.print();
+    // ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle']
+    const entries2 = dq2.map((el, i) => [i, el]);
+    const avl2 = new AVLTree(entries2);
+    avl2.print();
+    //     ___3_______
+    //    /           \
+    //   _1_       ___7_
+    //  /   \     /     \
+    //  0   2    _5_    8_
+    //          /   \     \
+    //          4   6     9
+    expect(avl2.size).toBe(10);
+  });
+});

package/test/integration/heap.test.js

@@ -1,4 +1,4 @@
-const { MinHeap } = require('heap-typed');
+const { MinHeap } = require('data-structure-typed');
 
 describe('JS Heap Operation Test', () => {
   it('should numeric heap work well', function () {

package/test/integration/index.html

@@ -86,7 +86,7 @@
     tree.print(undefined, { isShowUndefined: true });
 
     const node3 = tree.getNode(3);
-    if (node3) node3.right = tree._createNode(1);
+    if (node3) node3.right = tree.createNode(1);
     console.log(tree.isPerfectlyBalanced(), `tree.isPerfectlyBalanced()`);
     tree.print();
 

package/test/performance/data-structures/comparison/comparison.test.ts

@@ -1,6 +1,4 @@
-import { PriorityQueue as MJSPriorityQueue } from '../../../../dist/esm';
-import { PriorityQueue as SRCPriorityQueue } from '../../../../src';
-import { PriorityQueue as CJSPriorityQueue } from '../../../../dist/cjs';
+import { Heap as SRCPriorityQueue } from '../../../../src';
 import {
   Deque as CDeque,
   HashMap as CHashMap,
@@ -16,93 +14,65 @@ import { getRandomIntArray, magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { TEN_THOUSAND, HUNDRED_THOUSAND, MILLION } = magnitude;
+const { HUNDRED_THOUSAND, MILLION } = magnitude;
 const cOrderedMap = new OrderedMap<number, number>();
 const arrHundredThousand = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND, true);
 
-suite
-  .add(`SRC PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
-    const pq = new SRCPriorityQueue<number>();
-    for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
-  })
-  .add(`CJS PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
-    const pq = new CJSPriorityQueue<number>();
-    for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
-  })
-  .add(`MJS PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
-    const pq = new MJSPriorityQueue<number>([], {
-      comparator: (a, b) => b - a
-    });
-    for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
-  });
+suite.add(`SRC PQ ${MILLION.toLocaleString()} add`, () => {
+  const pq = new SRCPriorityQueue<number>();
+  for (let i = 0; i < MILLION; i++) pq.add(i);
+});
 
 if (isCompetitor) {
-  suite.add(`CPT PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
+  suite.add(`CPT PQ ${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
     const pq = new CPriorityQueue<number>();
-    for (let i = 0; i < TEN_THOUSAND; i++) pq.push(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.push(i);
   });
 }
 
-suite
-  .add(`SRC PQ ${TEN_THOUSAND.toLocaleString()} add & poll`, () => {
-    const pq = new SRCPriorityQueue<number>([], {
-      comparator: (a, b) => b - a
-    });
-
-    for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
-    for (let i = 0; i < TEN_THOUSAND; i++) pq.poll();
-  })
-  .add(`CJS PQ ${TEN_THOUSAND.toLocaleString()} add & poll`, () => {
-    const pq = new CJSPriorityQueue<number>([], {
-      comparator: (a, b) => b - a
-    });
-
-    for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
-    for (let i = 0; i < TEN_THOUSAND; i++) pq.poll();
-  })
-  .add(`MJS PQ ${TEN_THOUSAND.toLocaleString()} add & poll`, () => {
-    const pq = new MJSPriorityQueue<number>([], {
-      comparator: (a, b) => b - a
-    });
-
-    for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
-    for (let i = 0; i < TEN_THOUSAND; i++) pq.poll();
+suite.add(`SRC PQ ${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
+  const pq = new SRCPriorityQueue<number>([], {
+    comparator: (a, b) => b - a
   });
 
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.add(i);
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.poll();
+});
+
 if (isCompetitor) {
   suite
-    .add(`CPT PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
+    .add(`CPT PQ ${MILLION.toLocaleString()} add & pop`, () => {
       const pq = new CPriorityQueue<number>();
 
-      for (let i = 0; i < TEN_THOUSAND; i++) pq.push(i);
-      for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();
+      for (let i = 0; i < MILLION; i++) pq.push(i);
+      for (let i = 0; i < MILLION; i++) pq.pop();
     })
     .add(`CPT OM ${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
       for (let i = 0; i < arrHundredThousand.length; i++)
         cOrderedMap.setElement(arrHundredThousand[i], arrHundredThousand[i]);
     })
-    .add(`CPT HM ${TEN_THOUSAND.toLocaleString()} set`, () => {
+    .add(`CPT HM ${HUNDRED_THOUSAND.toLocaleString()} set`, () => {
       const hm = new CHashMap<number, number>();
 
-      for (let i = 0; i < TEN_THOUSAND; i++) hm.setElement(i, i);
+      for (let i = 0; i < HUNDRED_THOUSAND; i++) hm.setElement(i, i);
     })
-    .add(`CPT HM ${TEN_THOUSAND.toLocaleString()} set & get`, () => {
+    .add(`CPT HM ${HUNDRED_THOUSAND.toLocaleString()} set & get`, () => {
       const hm = new CHashMap<number, number>();
 
-      for (let i = 0; i < TEN_THOUSAND; i++) hm.setElement(i, i);
-      for (let i = 0; i < TEN_THOUSAND; i++) hm.getElementByKey(i);
+      for (let i = 0; i < HUNDRED_THOUSAND; i++) hm.setElement(i, i);
+      for (let i = 0; i < HUNDRED_THOUSAND; i++) hm.getElementByKey(i);
     })
     .add(`CPT LL ${MILLION.toLocaleString()} unshift`, () => {
       const list = new CLinkedList<number>();
 
       for (let i = 0; i < MILLION; i++) list.pushFront(i);
     })
-    .add(`CPT PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
+    .add(`CPT PQ ${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
       const pq = new CPriorityQueue<number>();
 
-      for (let i = 0; i < TEN_THOUSAND; i++) pq.push(i);
+      for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.push(i);
 
-      for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();
+      for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.pop();
     })
     .add(`CPT DQ ${MILLION.toLocaleString()} push`, () => {
       const deque = new CDeque<number>();
@@ -126,4 +96,4 @@ if (isCompetitor) {
     });
 }
 
-// export { suite };
+export { suite };

package/test/unit/data-structures/binary-tree/binary-tree.test.ts

@@ -152,7 +152,7 @@ describe('BinaryTree', () => {
   it('delete(): leaf/one-child/two-children/missing; updates size and minHeight', () => {
     expect(binTree.getHeight(binTree.root, 'ITERATIVE')).toBe(-1);
     expect(binTree.getMinHeight()).toBe(-1);
-    const node1 = binTree._createNode(1);
+    const node1 = binTree.createNode(1);
     binTree.add(node1);
     expect(binTree.size).toBe(1);
 
@@ -261,7 +261,7 @@ describe('BinaryTree', () => {
     expect(binTree.isPerfectlyBalanced()).toBe(true);
     const node3 = binTree.getNode(3);
 
-    if (node3) node3.right = binTree._createNode(1);
+    if (node3) node3.right = binTree.createNode(1);
     expect(binTree.isPerfectlyBalanced()).toBe(false);
 
     binTree.clear();
@@ -1587,7 +1587,7 @@ describe('Coverage boosters - close remaining uncovered branches', () => {
 
   it('add(): build tree with no undefined child slot -> return false path', () => {
     const t = new BinaryTree<number>();
-    const r = t._createNode(1)!;
+    const r = t.createNode(1)!;
     // explicitly set left/right child pointers to null (not undefined) so BFS finds no insertion slot
     (r as any).left = null;
     (r as any).right = null;