data-structure-typed 1.50.4 → 1.50.6

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

@@ -178,72 +178,6 @@ export class Queue<E = any> extends IterableElementBase<E> {
     return spliced.length === 1;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `peek` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
-   * @returns The `peek()` method returns the first element of the data structure, represented by the `_elements` array at
-   * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
-   */
-  peek(): E | undefined {
-    return this.first;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `peekLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
-   * @returns The method `peekLast()` returns the last element of the `_elements` array if the array is not empty. If the
-   * array is empty, it returns `undefined`.
-   */
-  peekLast(): E | undefined {
-    return this.last;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The enqueue function adds a value to the end of a queue.
-   * @param {E} value - The value parameter represents the value that you want to add to the queue.
-   */
-  enqueue(value: E): boolean {
-    return this.push(value);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
-   * @returns The method is returning a value of type E or undefined.
-   */
-  dequeue(): E | undefined {
-    return this.shift();
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -411,38 +345,6 @@ export class Queue<E = any> extends IterableElementBase<E> {
  * 4. Frequent Enqueuing and Dequeuing Operations: If your application involves frequent enqueuing and dequeuing operations and is less concerned with random access, then LinkedListQueue is a good choice.
  */
 export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
-  /**
-   * The `get first` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-   * @returns The `get first()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
-   */
-  get first(): E | undefined {
-    return this.head?.value;
-  }
-
-  /**
-   * The enqueue function adds a value to the end of an array.
-   * @param {E} value - The value parameter represents the value that you want to add to the queue.
-   */
-  enqueue(value: E): boolean {
-    return this.push(value);
-  }
-
-  /**
-   * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
-   * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
-   */
-  dequeue(): E | undefined {
-    return this.shift();
-  }
-
-  /**
-   * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-   * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
-   */
-  peek(): E | undefined {
-    return this.first;
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)

package/test/performance/data-structures/binary-tree/avl-tree.test.ts

@@ -12,6 +12,9 @@ suite
     avl.clear();
     for (let i = 0; i < arr.length; i++) avl.add(arr[i]);
   })
+  .add(`${TEN_THOUSAND.toLocaleString()} get`, () => {
+    for (let i = 0; i < arr.length; i++) avl.get(arr[i]);
+  })
   .add(`${TEN_THOUSAND.toLocaleString()} add & delete randomly`, () => {
     avl.clear();
     for (let i = 0; i < arr.length; i++) avl.add(arr[i]);
@@ -20,9 +23,6 @@ suite
   .add(`${TEN_THOUSAND.toLocaleString()} addMany`, () => {
     avl.clear();
     avl.addMany(arr);
-  })
-  .add(`${TEN_THOUSAND.toLocaleString()} get`, () => {
-    for (let i = 0; i < arr.length; i++) avl.get(arr[i]);
   });
 
 export { suite };

package/test/performance/data-structures/binary-tree/binary-tree-overall.test.ts

@@ -25,13 +25,13 @@ suite
     avlTree.clear();
     for (let i = 0; i < arr.length; i++) avlTree.add(arr[i]);
   })
+  .add(`${TEN_THOUSAND.toLocaleString()} AVLTree get`, () => {
+    for (let i = 0; i < arr.length; i++) avlTree.get(arr[i]);
+  })
   .add(`${TEN_THOUSAND.toLocaleString()} AVLTree add & delete randomly`, () => {
     avlTree.clear();
     for (let i = 0; i < arr.length; i++) avlTree.add(arr[i]);
     for (let i = 0; i < arr.length; i++) avlTree.delete(arr[i]);
-  })
-  .add(`${TEN_THOUSAND.toLocaleString()} AVLTree get`, () => {
-    for (let i = 0; i < arr.length; i++) avlTree.get(arr[i]);
   });
 
 export { suite };

package/test/performance/data-structures/binary-tree/rb-tree.test.ts

@@ -7,33 +7,43 @@ import { isCompetitor } from '../../../config';
 const suite = new Benchmark.Suite();
 const rbTree = new RedBlackTree();
 const { HUNDRED_THOUSAND } = magnitude;
-const arr = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND, true);
+const randomArray = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND - 1, true);
 const cOrderedMap = new OrderedMap<number, number>();
 
-suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
-  rbTree.clear();
-  for (let i = 0; i < arr.length; i++) rbTree.add(arr[i]);
-});
+suite
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add orderly`, () => {
+    for (let i = 0; i < randomArray.length; i++) rbTree.add(i);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} delete orderly`, () => {
+    for (let i = 0; i < randomArray.length; i++) rbTree.delete(i);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add randomly`, () => {
+    rbTree.clear();
+    for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} delete randomly`, () => {
+    for (let i = 0; i < randomArray.length; i++) rbTree.delete(randomArray[i]);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add orderly`, () => {
+    for (let i = 0; i < randomArray.length; i++) rbTree.add(i);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} delete randomly`, () => {
+    for (let i = 0; i < randomArray.length; i++) rbTree.delete(randomArray[i]);
+  });
 
 if (isCompetitor) {
   suite.add(`CPT ${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
-    for (let i = 0; i < arr.length; i++) cOrderedMap.setElement(arr[i], arr[i]);
+    for (let i = 0; i < randomArray.length; i++) cOrderedMap.setElement(randomArray[i], randomArray[i]);
   });
 }
 
-suite
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete randomly`, () => {
-    rbTree.clear();
-    for (let i = 0; i < arr.length; i++) rbTree.add(arr[i]);
-    for (let i = 0; i < arr.length; i++) rbTree.delete(arr[i]);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} getNode`, () => {
-    for (let i = 0; i < arr.length; i++) rbTree.getNode(arr[i]);
-  });
+suite.add(`${HUNDRED_THOUSAND.toLocaleString()} getNode randomly`, () => {
+  for (let i = 0; i < randomArray.length; i++) rbTree.getNode(randomArray[i]);
+});
 
 suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & iterator`, () => {
   rbTree.clear();
-  for (let i = 0; i < arr.length; i++) rbTree.add(arr[i]);
+  for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
   const entries = [...rbTree];
   return entries.length === HUNDRED_THOUSAND;
 });

package/test/performance/data-structures/hash/hash-map.test.ts

@@ -21,13 +21,13 @@ if (isCompetitor) {
   });
 }
 
-suite.add(`Native Map ${MILLION.toLocaleString()} set`, () => {
+suite.add(`Native JS Map ${MILLION.toLocaleString()} set`, () => {
   const hm = new Map<number, number>();
 
   for (let i = 0; i < MILLION; i++) hm.set(i, i);
 });
 
-suite.add(`Native Set ${MILLION.toLocaleString()} add`, () => {
+suite.add(`Native JS Set ${MILLION.toLocaleString()} add`, () => {
   const hs = new Set<number>();
 
   for (let i = 0; i < MILLION; i++) hs.add(i);
@@ -49,14 +49,14 @@ if (isCompetitor) {
   });
 }
 
-suite.add(`Native Map ${MILLION.toLocaleString()} set & get`, () => {
+suite.add(`Native JS Map ${MILLION.toLocaleString()} set & get`, () => {
   const hm = new Map<number, number>();
 
   for (let i = 0; i < MILLION; i++) hm.set(i, i);
   for (let i = 0; i < MILLION; i++) hm.get(i);
 });
 
-suite.add(`Native Set ${MILLION.toLocaleString()} add & has`, () => {
+suite.add(`Native JS Set ${MILLION.toLocaleString()} add & has`, () => {
   const hs = new Set<number>();
 
   for (let i = 0; i < MILLION; i++) hs.add(i);
@@ -74,7 +74,7 @@ suite.add(`${MILLION.toLocaleString()} ObjKey set & get`, () => {
   for (let i = 0; i < MILLION; i++) hm.get(objKeys[i]);
 });
 
-suite.add(`Native Map ${MILLION.toLocaleString()} ObjKey set & get`, () => {
+suite.add(`Native JS Map ${MILLION.toLocaleString()} ObjKey set & get`, () => {
   const hm = new Map<[number, number], number>();
   const objs: [number, number][] = [];
   for (let i = 0; i < MILLION; i++) {
@@ -85,7 +85,7 @@ suite.add(`Native Map ${MILLION.toLocaleString()} ObjKey set & get`, () => {
   for (let i = 0; i < MILLION; i++) hm.get(objs[i]);
 });
 
-suite.add(`Native Set ${MILLION.toLocaleString()} ObjKey add & has`, () => {
+suite.add(`Native JS Set ${MILLION.toLocaleString()} ObjKey add & has`, () => {
   const hs = new Set<[number, number]>();
   const objs: [number, number][] = [];
   for (let i = 0; i < MILLION; i++) {

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

@@ -1,26 +1,26 @@
-import { FibonacciHeap, Heap } from '../../../../src';
+import { Heap } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import { magnitude } from '../../../utils';
+import { getRandomInt, magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const { HUNDRED_THOUSAND, TEN_THOUSAND } = magnitude;
+const { HUNDRED_THOUSAND } = magnitude;
+const indicesHT = new Array(HUNDRED_THOUSAND).fill(0).map(() => getRandomInt(0, HUNDRED_THOUSAND - 1));
 
 suite
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
+    const heap = new Heap<number>([], { comparator: (a, b) => b - a });
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(indicesHT[i]);
+  })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
     const heap = new Heap<number>([], { comparator: (a, b) => b - a });
 
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(indicesHT[i]);
     for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.poll();
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & dfs`, () => {
-    const heap = new Heap<number>([], { comparator: (a, b) => b - a });
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(i);
-    heap.dfs();
-  })
-  .add(`${TEN_THOUSAND.toLocaleString()} fib add & pop`, () => {
-    const fbHeap = new FibonacciHeap<number>();
-    for (let i = 1; i <= TEN_THOUSAND; i++) fbHeap.push(i);
-    for (let i = 1; i <= TEN_THOUSAND; i++) fbHeap.pop();
   });
+// .add(`${TEN_THOUSAND.toLocaleString()} fib add & pop`, () => {
+//   const fbHeap = new FibonacciHeap<number>();
+//   for (let i = 1; i <= TEN_THOUSAND; i++) fbHeap.push(i);
+//   for (let i = 1; i <= TEN_THOUSAND; i++) fbHeap.pop();
+// });
 
 export { suite };

package/test/performance/data-structures/priority-queue/priority-queue.test.ts

@@ -1,5 +1,5 @@
-import { PriorityQueue as CPriorityQueue } from 'js-sdsl';
 import { PriorityQueue } from '../../../../src';
+import { PriorityQueue as CPriorityQueue } from 'js-sdsl';
 import * as Benchmark from 'benchmark';
 import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
@@ -7,12 +7,17 @@ import { isCompetitor } from '../../../config';
 const suite = new Benchmark.Suite();
 const { HUNDRED_THOUSAND } = magnitude;
 
-suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
-  const pq = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
+suite
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
+    const heap = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(i);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
+    const heap = new PriorityQueue<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();
-});
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.poll();
+  });
 if (isCompetitor) {
   suite.add(`CPT ${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
     const pq = new CPriorityQueue<number>();

package/test/performance/data-structures/queue/deque.test.ts

@@ -21,25 +21,25 @@ if (isCompetitor) {
 }
 
 suite
-  // .add(`${TEN_THOUSAND.toLocaleString()} push & delete`, () => {
-  //   const deque = new Deque<number>();
-  //
-  //   for (let i = 0; i < TEN_THOUSAND; i++) deque.push(i);
-  //   for (let i = 0; i < TEN_THOUSAND; i++) deque.delete(randomIndicesTenThousand[i]);
-  // })
   .add(`${MILLION.toLocaleString()} push & pop`, () => {
     const deque = new Deque<number>();
 
     for (let i = 0; i < MILLION; i++) deque.push(i);
     for (let i = 0; i < MILLION; i++) deque.pop();
   })
+  .add(`${MILLION.toLocaleString()} push & shift`, () => {
+    const deque = new Deque<number>();
+
+    for (let i = 0; i < MILLION; i++) deque.push(i);
+    for (let i = 0; i < MILLION; i++) deque.shift();
+  })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
     const deque = new Deque<number>();
 
     for (let i = 0; i < HUNDRED_THOUSAND; i++) deque.push(i);
     for (let i = 0; i < HUNDRED_THOUSAND; i++) deque.shift();
   })
-  .add(`Native Array ${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
+  .add(`Native JS Array ${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
     const array = new Array<number>();
 
     for (let i = 0; i < HUNDRED_THOUSAND; i++) array.push(i);
@@ -51,7 +51,7 @@ suite
     for (let i = 0; i < HUNDRED_THOUSAND; i++) deque.unshift(i);
     for (let i = 0; i < HUNDRED_THOUSAND; i++) deque.shift();
   })
-  .add(`Native Array ${HUNDRED_THOUSAND.toLocaleString()} unshift & shift`, () => {
+  .add(`Native JS Array ${HUNDRED_THOUSAND.toLocaleString()} unshift & shift`, () => {
     const array = new Array<number>();
 
     for (let i = 0; i < HUNDRED_THOUSAND; i++) array.unshift(i);

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

@@ -25,18 +25,11 @@ suite.add(`${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
   for (let i = 0; i < HUNDRED_THOUSAND; i++) queue.push(i);
   for (let i = 0; i < HUNDRED_THOUSAND; i++) queue.shift();
 });
-suite
-  .add(`Native Array ${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
-    const arr = new Array<number>();
+suite.add(`Native JS Array ${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
+  const arr = new Array<number>();
 
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) arr.push(i);
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) arr.shift();
-  })
-  .add(`Native Array ${HUNDRED_THOUSAND.toLocaleString()} push & pop`, () => {
-    const arr = new Array<number>();
-
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) arr.push(i);
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) arr.pop();
-  });
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) arr.push(i);
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) arr.shift();
+});
 
 export { suite };

package/test/performance/reportor.ts

@@ -4,6 +4,7 @@ import * as fs from 'fs';
 import * as fastGlob from 'fast-glob';
 import { Color, numberFix, render } from '../utils';
 import { PerformanceTest } from './types';
+import * as console from 'console';
 
 const args = process.argv.slice(2);
 
@@ -171,7 +172,48 @@ function replaceMarkdownContent(startMarker: string, endMarker: string, newText:
   });
 }
 
-performanceTests.forEach(item => {
+const order = [
+  'heap',
+  'rb-tree',
+  'queue',
+  'deque',
+  'hash-map',
+  'trie',
+  'avl-tree',
+  'binary-tree-overall',
+  'directed-graph',
+  'doubly-linked-list',
+  'singly-linked-list',
+  'priority-queue',
+  'stack'
+];
+
+const sortedPerformanceTests = [...performanceTests].sort((a, b) => {
+  const indexA = order.indexOf(a.testName);
+  const indexB = order.indexOf(b.testName);
+
+  // If both a and b are in the order, sort them according to their indices in the order.
+  if (indexA !== -1 && indexB !== -1) {
+    return indexA - indexB;
+  }
+
+  // If there is only 'a' in the order, then place 'b' in front.
+  if (indexA !== -1) {
+    return 1;
+  }
+
+  // If only b is in the order, then a should be placed before it.
+  if (indexB !== -1) {
+    return -1;
+  }
+
+  // If neither a nor b are in order, keep their original order
+  return 0;
+});
+
+console.log(`${GREEN} Found tests${END}: ${sortedPerformanceTests.map(test => test.testName)}`);
+
+sortedPerformanceTests.forEach(item => {
   const { suite, testName, file } = item;
 
   console.log(coloredLabeled('Running', file));

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

@@ -158,40 +158,41 @@ describe('Overall BinaryTree Test', () => {
     tmm.add(5);
     tmm.add(4);
     expect(tmm.count).toBe(10);
-    expect(tmm.root?.key).toBe(6);
+    expect(tmm.root?.key).toBe(3);
     expect(tmm.root?.left?.key).toBe(1);
     expect(tmm.root?.left?.left?.key).toBe(NaN);
     expect(tmm.root?.right?.key).toBe(7);
-    expect(tmm.root?.right?.left?.key).toBe(NaN);
-    expect(tmm.getNodeByKey(7)?.left?.key).toBe(NaN);
-    expect(tmm.getHeight()).toBe(5);
+    expect(tmm.root?.right?.left?.key).toBe(5);
+    expect(tmm.getNodeByKey(7)?.left?.key).toBe(5);
+    expect(tmm.getHeight()).toBe(3);
     expect(tmm.has(9)).toBe(true);
     expect(tmm.has(7)).toBe(true);
     expect(tmm.delete(7)[0].deleted?.key).toBe(7);
     expect(tmm.has(7)).toBe(false);
     expect(tmm.size).toBe(7);
     expect(tmm.count).toBe(9);
-    expect(tmm.root?.key).toBe(6);
+    expect(tmm.root?.key).toBe(3);
     expect(tmm.root?.left?.key).toBe(1);
     expect(tmm.root?.right?.key).toBe(9);
-    expect(tmm.root?.right?.left?.key).toBe(NaN);
-    expect(tmm.getNodeByKey(6)?.left?.key).toBe(1);
-    expect(tmm.getHeight()).toBe(5);
+    expect(tmm.root?.right?.left?.key).toBe(5);
+    expect(tmm.getNodeByKey(6)?.left?.key).toBe(NaN);
+    expect(tmm.getHeight()).toBe(3);
     expect(tmm.has(9)).toBe(true);
     expect(tmm.has(7)).toBe(false);
-    expect(tmm.bfs()).toEqual([6, 1, 9, 3, 2, 5, 4]);
+    expect(tmm.bfs()).toEqual([3, 1, 9, 2, 5, 4, 6]);
+    // expect(tmm.bfs()).toEqual([6, 1, 9, 3, 2, 5, 4]);
     const clonedTMM = tmm.clone();
     expect(clonedTMM.size).toBe(7);
     expect(clonedTMM.count).toBe(9);
-    expect(clonedTMM.root?.key).toBe(6);
+    expect(clonedTMM.root?.key).toBe(3);
     expect(clonedTMM.root?.left?.key).toBe(1);
-    expect(clonedTMM.root?.right?.key).toBe(9);
-    expect(clonedTMM.root?.right?.left?.key).toBe(NaN);
-    expect(clonedTMM.getNodeByKey(6)?.left?.key).toBe(1);
-    expect(clonedTMM.getHeight()).toBe(5);
+    expect(clonedTMM.root?.right?.key).toBe(5);
+    expect(clonedTMM.root?.right?.left?.key).toBe(4);
+    expect(clonedTMM.getNodeByKey(6)?.left?.key).toBe(NaN);
+    expect(clonedTMM.getHeight()).toBe(3);
     expect(clonedTMM.has(9)).toBe(true);
     expect(clonedTMM.has(7)).toBe(false);
-    expect(clonedTMM.bfs()).toEqual([6, 1, 9, 3, 2, 5, 4]);
+    expect(clonedTMM.bfs()).toEqual([3, 1, 5, 2, 4, 9, 6]);
   });
 
   it('Should clone a RedBlackTree works fine', () => {
@@ -211,7 +212,7 @@ describe('Overall BinaryTree Test', () => {
     expect(rbTree.root?.right?.key).toBe(7);
     expect(rbTree.root?.right?.left?.key).toBe(5);
     expect(rbTree.getNodeByKey(7)?.left?.key).toBe(5);
-    expect(rbTree.getHeight()).toBe(4);
+    expect(rbTree.getHeight()).toBe(3);
     expect(rbTree.has(9)).toBe(true);
     expect(rbTree.has(7)).toBe(true);
     expect(rbTree.delete(7)?.[0]?.deleted?.key).toBe(7);
@@ -219,13 +220,14 @@ describe('Overall BinaryTree Test', () => {
     expect(rbTree.size).toBe(7);
     expect(rbTree.root?.key).toBe(3);
     expect(rbTree.root?.left?.key).toBe(1);
-    expect(rbTree.root?.right?.key).toBe(5);
-    expect(rbTree.root?.right?.left?.key).toBe(4);
+    expect(rbTree.root?.right?.key).toBe(9);
+    expect(rbTree.root?.right?.left?.key).toBe(5);
     expect(rbTree.getNodeByKey(6)?.left?.key).toBe(NaN);
-    expect(rbTree.getHeight()).toBe(4);
+    expect(rbTree.getHeight()).toBe(3);
     expect(rbTree.has(9)).toBe(true);
     expect(rbTree.has(7)).toBe(false);
-    expect(rbTree.bfs()).toEqual([3, 1, 5, 2, 4, 9, 6]);
+    // expect(rbTree.bfs()).toEqual([3, 1, 5, 2, 4, 9, 6]);
+    expect(rbTree.bfs()).toEqual([3, 1, 9, 2, 5, 4, 6]);
     const clonedRbTree = rbTree.clone();
     expect(clonedRbTree.size).toBe(7);
     expect(clonedRbTree.root?.key).toBe(3);
@@ -233,7 +235,7 @@ describe('Overall BinaryTree Test', () => {
     expect(clonedRbTree.root?.right?.key).toBe(5);
     expect(clonedRbTree.root?.right?.left?.key).toBe(4);
     expect(clonedRbTree.getNodeByKey(6)?.left?.key).toBe(NaN);
-    expect(clonedRbTree.getHeight()).toBe(4);
+    expect(clonedRbTree.getHeight()).toBe(3);
     expect(clonedRbTree.has(9)).toBe(true);
     expect(clonedRbTree.has(7)).toBe(false);
     expect(clonedRbTree.bfs()).toEqual([3, 1, 5, 2, 4, 9, 6]);