data-structure-typed 1.50.0 → 1.50.2

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

@@ -32,12 +32,20 @@ export class Queue<E = any> extends IterableElementBase<E> {
 
   protected _elements: E[] = [];
 
+  /**
+   * The elements function returns the elements of this set.
+   * @return An array of the elements in the stack
+   */
   get elements(): E[] {
     return this._elements;
   }
 
   protected _offset: number = 0;
 
+  /**
+   * The offset function returns the offset of the current page.
+   * @return The value of the private variable _offset
+   */
   get offset(): number {
     return this._offset;
   }
@@ -142,6 +150,26 @@ export class Queue<E = any> extends IterableElementBase<E> {
     return first;
   }
 
+  /**
+   * The delete function removes an element from the list.
+   * @param element: E Specify the element to be deleted
+   * @return A boolean value indicating whether the element was successfully deleted or not
+   */
+  delete(element: E): boolean {
+    const index = this.elements.indexOf(element);
+    return this.deleteAt(index);
+  }
+
+  /**
+   * The deleteAt function deletes the element at a given index.
+   * @param index: number Determine the index of the element to be deleted
+   * @return A boolean value
+   */
+  deleteAt(index: number): boolean {
+    const spliced = this.elements.splice(index, 1);
+    return spliced.length === 1;
+  }
+
   /**
    * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
    * Space Complexity: O(1) - no additional space is used.
@@ -219,7 +247,7 @@ export class Queue<E = any> extends IterableElementBase<E> {
    *
    * @param index
    */
-  getAt(index: number): E | undefined {
+  at(index: number): E | undefined {
     return this.elements[index];
   }
 
@@ -264,13 +292,14 @@ export class Queue<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n) - where n is the number of elements in the queue. It creates a shallow copy of the internal array.
-   * Space Complexity: O(n) - the space required is proportional to the number of elements in the queue.
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   * where n is the number of elements in the queue. It creates a shallow copy of the internal array. the space required is proportional to the number of elements in the queue.
    */
 
   /**
-   * Time Complexity: O(n) - where n is the number of elements in the queue. It creates a shallow copy of the internal array.
-   * Space Complexity: O(n) - the space required is proportional to the number of elements in the queue.
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
    *
    * The `clone()` function returns a new Queue object with the same elements as the original Queue.
    * @returns The `clone()` method is returning a new instance of the `Queue` class.
@@ -390,4 +419,21 @@ export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
   peek(): E | undefined {
     return this.first;
   }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   * The `clone` function returns a new instance of the `LinkedListQueue` class with the same values as
+   * the current instance.
+   * @returns The `clone()` method is returning a new instance of `LinkedListQueue` with the same
+   * values as the original `LinkedListQueue`.
+   */
+  clone(): LinkedListQueue<E> {
+    return new LinkedListQueue<E>(this.values());
+  }
 }

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

@@ -32,6 +32,10 @@ export class Stack<E = any> extends IterableElementBase<E> {
 
   protected _elements: E[] = [];
 
+  /**
+   * The elements function returns the elements of this set.
+   * @return An array of elements
+   */
   get elements(): E[] {
     return this._elements;
   }
@@ -125,6 +129,26 @@ export class Stack<E = any> extends IterableElementBase<E> {
     return this.elements.pop();
   }
 
+  /**
+   * The delete function removes an element from the stack.
+   * @param element: E Specify the element to be deleted
+   * @return A boolean value indicating whether the element was successfully deleted or not
+   */
+  delete(element: E): boolean {
+    const index = this.elements.indexOf(element);
+    return this.deleteAt(index);
+  }
+
+  /**
+   * The deleteAt function deletes the element at a given index.
+   * @param index: number Determine the index of the element to be deleted
+   * @return A boolean value
+   */
+  deleteAt(index: number): boolean {
+    const spliced = this.elements.splice(index, 1);
+    return spliced.length === 1;
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)

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

@@ -37,7 +37,13 @@ export class TrieNode {
  * 10. IP Routing: Used in certain types of IP routing algorithms.
  * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data."
  */
-export class Trie extends IterableElementBase<string> {
+export class Trie extends IterableElementBase<string, Trie> {
+  /**
+   * The constructor function for the Trie class.
+   * @param words: Iterable string Initialize the trie with a set of words
+   * @param options?: TrieOptions Allow the user to pass in options for the trie
+   * @return This
+   */
   constructor(words: Iterable<string> = [], options?: TrieOptions) {
     super();
     if (options) {
@@ -51,18 +57,31 @@ export class Trie extends IterableElementBase<string> {
 
   protected _size: number = 0;
 
+  /**
+   * The size function returns the size of the stack.
+   * @return The number of elements in the list
+   */
   get size(): number {
     return this._size;
   }
 
   protected _caseSensitive: boolean = true;
 
+  /**
+   * The caseSensitive function is a getter that returns the value of the private _caseSensitive property.
+   *
+   * @return The value of the _casesensitive private variable
+   */
   get caseSensitive(): boolean {
     return this._caseSensitive;
   }
 
   protected _root: TrieNode = new TrieNode('');
 
+  /**
+   * The root function returns the root node of the tree.
+   * @return The root node
+   */
   get root() {
     return this._root;
   }
@@ -124,6 +143,14 @@ export class Trie extends IterableElementBase<string> {
     return cur.isEnd;
   }
 
+  /**
+   * The isEmpty function checks if the size of the queue is 0.
+   * @return True if the size of the queue is 0
+   */
+  isEmpty(): boolean {
+    return this.size === 0;
+  }
+
   /**
    * Time Complexity: O(M), where M is the length of the word being deleted.
    * Space Complexity: O(M) - Due to the recursive DFS approach.
@@ -351,6 +378,23 @@ export class Trie extends IterableElementBase<string> {
     return words;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `clone` function returns a new instance of the Trie class with the same values and case
+   * sensitivity as the original Trie.
+   * @returns A new instance of the Trie class is being returned.
+   */
+  clone(): Trie {
+    return new Trie(this.values(), { caseSensitive: this.caseSensitive });
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)

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

@@ -3,7 +3,7 @@ import { IterationType } from "../../common";
 
 export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type BinaryTreeNested<K, V, N extends BinaryTreeNode<K, V, N>> = BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+export type BinaryTreeNested<K, V, NODE extends BinaryTreeNode<K, V, NODE>> = BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
 export type BinaryTreeOptions<K> = {
   iterationType?: IterationType,

package/src/types/data-structures/hash/hash-map.ts

@@ -5,14 +5,15 @@ export type HashMapLinkedNode<K, V> = {
   prev: HashMapLinkedNode<K, V>;
 };
 
-export type LinkedHashMapOptions<K> = {
+export type LinkedHashMapOptions<K, V, R> = {
   hashFn?: (key: K) => string;
   objHashFn?: (key: K) => object;
+  toEntryFn?: (rawElement: R) => [K, V];
 };
 
-export type HashMapOptions<K, V, T> = {
+export type HashMapOptions<K, V, R> = {
   hashFn?: (key: K) => string;
-  toEntryFn?: (rawElement: T) => [K, V];
+  toEntryFn?: (rawElement: R) => [K, V];
 };
 
 export type HashMapStoreItem<K, V> = { key: K; value: V };

package/src/types/utils/utils.ts

@@ -4,3 +4,5 @@ export type TrlFn = (...args: any[]) => any;
 export type TrlAsyncFn = (...args: any[]) => any;
 
 export type SpecifyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+export type Any = string | number | boolean | object | null | undefined | symbol;

package/test/performance/data-structures/graph/directed-graph.test.ts

@@ -28,9 +28,9 @@ suite
   .add(`tarjan`, () => {
     graph.tarjan(true);
   })
-  .add(`tarjan all`, () => {
-    graph.tarjan(true, true, true, true);
-  })
+  // .add(`tarjan all`, () => {
+  //   graph.tarjan(true, true, true, true);
+  // })
   .add(`topologicalSort`, () => {
     graph.topologicalSort('key');
   });

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

@@ -1,11 +1,12 @@
 import { Deque } from '../../../../src';
 import { Deque as CDeque } from 'js-sdsl';
 import * as Benchmark from 'benchmark';
-import { getRandomInt, magnitude } from '../../../utils';
+import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 export const suite = new Benchmark.Suite();
-const { MILLION, HUNDRED_THOUSAND, TEN_THOUSAND } = magnitude;
+const { MILLION, HUNDRED_THOUSAND } = magnitude;
+// const randomIndicesTenThousand = new Array(TEN_THOUSAND).fill(getRandomInt(0, TEN_THOUSAND - 1));
 
 suite.add(`${MILLION.toLocaleString()} push`, () => {
   const deque = new Deque<number>();
@@ -14,45 +15,45 @@ suite.add(`${MILLION.toLocaleString()} push`, () => {
 
 if (isCompetitor) {
   suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
-    const _deque = new CDeque<number>();
-    for (let i = 0; i < MILLION; i++) _deque.pushBack(i);
+    const deque = new CDeque<number>();
+    for (let i = 0; i < MILLION; i++) deque.pushBack(i);
   });
 }
 
 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(getRandomInt(0, TEN_THOUSAND - 1));
-  })
+  // .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>();
+    const deque = new Deque<number>();
 
-    for (let i = 0; i < MILLION; i++) _deque.push(i);
-    for (let i = 0; i < MILLION; i++) _deque.pop();
+    for (let i = 0; i < MILLION; i++) deque.push(i);
+    for (let i = 0; i < MILLION; i++) deque.pop();
   })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
-    const _deque = new Deque<number>();
+    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();
+    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`, () => {
-    const _deque = new Array<number>();
+    const array = new Array<number>();
 
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) _deque.push(i);
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) _deque.shift();
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) array.push(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) array.shift();
   })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} unshift & shift`, () => {
-    const _deque = new Deque<number>();
+    const deque = new Deque<number>();
 
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) _deque.unshift(i);
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) _deque.shift();
+    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`, () => {
-    const _deque = new Array<number>();
+    const array = new Array<number>();
 
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) _deque.unshift(i);
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) _deque.shift();
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) array.unshift(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) array.shift();
   });

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

@@ -235,6 +235,43 @@ describe('AVLTree APIs test', () => {
     const bfsRes = avl.bfs(node => node.key);
     expect(bfsRes[0]).toBe(2);
   });
+
+  it('should the clone method', () => {
+    function checkTreeStructure(avl: AVLTree<string, number>) {
+      expect(avl.size).toBe(4);
+      expect(avl.root?.key).toBe('2');
+      expect(avl.root?.left?.key).toBe('1');
+      expect(avl.root?.left?.left?.key).toBe(undefined);
+      expect(avl.root?.left?.right?.key).toBe(undefined);
+      expect(avl.root?.right?.key).toBe('4');
+      expect(avl.root?.right?.left?.key).toBe(undefined);
+      expect(avl.root?.right?.right?.key).toBe('5');
+    }
+
+    const avl = new AVLTree<string, number>();
+    avl.addMany([
+      ['2', 2],
+      ['4', 4],
+      ['5', 5],
+      ['3', 3],
+      ['1', 1]
+    ]);
+    expect(avl.size).toBe(5);
+    expect(avl.root?.key).toBe('2');
+    expect(avl.root?.left?.key).toBe('1');
+    expect(avl.root?.left?.left?.key).toBe(undefined);
+    expect(avl.root?.left?.right?.key).toBe(undefined);
+    expect(avl.root?.right?.key).toBe('4');
+    expect(avl.root?.right?.left?.key).toBe('3');
+    expect(avl.root?.right?.right?.key).toBe('5');
+    avl.delete('3');
+    checkTreeStructure(avl);
+    const cloned = avl.clone();
+    checkTreeStructure(cloned);
+    cloned.delete('1');
+    expect(avl.size).toBe(4);
+    expect(cloned.size).toBe(3);
+  });
 });
 
 describe('AVLTree', () => {

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

@@ -152,6 +152,51 @@ describe('BinaryTree', () => {
     expect(tree.has('3', node => node.value?.toString())).toBe(true);
   });
 
+  it('should the clone method work fine', () => {
+    expect(tree.isEmpty()).toBe(true);
+    tree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
+    expect(tree.root?.key).toBe(4);
+    expect(tree.root?.left?.key).toBe(2);
+    expect(tree.root?.left?.left).toBe(null);
+    expect(tree.root?.left?.right?.key).toBe(1);
+    expect(tree.root?.right?.key).toBe(6);
+    expect(tree.root?.right?.left?.key).toBe(3);
+    expect(tree.root?.right?.right).toBe(null);
+
+    const cloned = tree.clone();
+    expect(cloned.root?.key).toBe(4);
+    expect(cloned.root?.left?.key).toBe(2);
+    expect(cloned.root?.left?.left).toBe(null);
+    expect(cloned.root?.left?.right?.key).toBe(1);
+    expect(cloned.root?.right?.key).toBe(6);
+    expect(cloned.root?.right?.left?.key).toBe(3);
+    expect(cloned.root?.right?.right).toBe(null);
+    expect(cloned.dfs(node => node.key, 'pre', cloned.getNode(6), IterationType.ITERATIVE)).toEqual([6, 3, 7]);
+    expect(
+      cloned.dfs(node => (node ? node.key : null), 'pre', cloned.getNode(6), IterationType.ITERATIVE, true)
+    ).toEqual([6, 3, 7, null]);
+    expect(
+      cloned.dfs(node => (node ? node.key : node), 'pre', cloned.getNode(6), IterationType.ITERATIVE, true)
+    ).toEqual([6, 3, 7, null]);
+    expect(
+      cloned.dfs(node => (node ? node.key : null), 'pre', cloned.getNode(6), IterationType.RECURSIVE, true)
+    ).toEqual([6, 3, 7, null]);
+    cloned.delete(6);
+    cloned.delete(3);
+    cloned.delete(7);
+    cloned.delete(1);
+    cloned.delete(5);
+    cloned.delete(4);
+    cloned.delete(2);
+    // cloned.delete(null);
+    // cloned.delete(null);
+    // cloned.delete(null);
+    expect(tree.size).toBe(10);
+    expect(cloned.size).toBe(3);
+    // expect(cloned.size).toBe(0);
+    // expect(cloned.isEmpty()).toBe(true);
+  });
+
   it('should be a balance tree after malicious manipulation', () => {
     tree.add(3);
     tree.add(12);
@@ -238,22 +283,6 @@ describe('BinaryTree', () => {
     expect(tree.getNodes(tree.getNodeByKey(2), undefined, false, tree.root)).toEqual([tree.getNodeByKey(2)]);
   });
 
-  // it('should subTreeTraverse', () => {
-  //   tree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
-  //   expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.ITERATIVE)).toEqual([6, 3, 7]);
-  //   expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.ITERATIVE, false)).toEqual([6, 3, 7]);
-  //   expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.RECURSIVE)).toEqual([6, 3, 7]);
-  //   expect(
-  //     tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.ITERATIVE, true)
-  //   ).toEqual([6, 3, 7, null]);
-  //   expect(
-  //     tree.subTreeTraverse(node => (node ? node.key : node), tree.getNode(6), IterationType.ITERATIVE, true)
-  //   ).toEqual([6, 3, 7, null]);
-  //   expect(
-  //     tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.RECURSIVE, true)
-  //   ).toEqual([6, 3, 7, null]);
-  // });
-
   it('should sub tree traverse', () => {
     tree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
     expect(tree.dfs(node => node.key, 'pre', tree.getNode(6), IterationType.ITERATIVE)).toEqual([6, 3, 7]);
@@ -613,7 +642,7 @@ describe('BinaryTree', () => {
     tree.delete(5);
     tree.delete(7);
     tree.delete(3);
-    expect(tree.root).toBe(null);
+    expect(tree.root).toBe(undefined);
     expect(tree.getHeight()).toBe(-1);
   });
 });

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

@@ -795,6 +795,70 @@ describe('BST operations test recursively', () => {
     expect(bfsNodes[1].key).toBe(12);
     expect(bfsNodes[2].key).toBe(16);
   });
+
+  it('should delete', () => {
+    const numBST = new BST<number>();
+    numBST.addMany([2, 4, 5, 3, 1]);
+    expect(numBST.size).toBe(5);
+    numBST.delete(1);
+    expect(numBST.size).toBe(4);
+
+    numBST.delete(2);
+    numBST.delete(3);
+    numBST.delete(4);
+    numBST.delete(5);
+    expect(numBST.size).toBe(0);
+    numBST.delete(5);
+    expect(numBST.size).toBe(0);
+  });
+
+  it('should the clone method', () => {
+    function checkTreeStructure(bst: BST<string, number>) {
+      expect(bst.size).toBe(4);
+      expect(bst.root?.key).toBe('2');
+      expect(bst.root?.left?.key).toBe('1');
+      expect(bst.root?.left?.left?.key).toBe(undefined);
+      expect(bst.root?.left?.right?.key).toBe(undefined);
+      expect(bst.root?.right?.key).toBe('4');
+      expect(bst.root?.right?.left?.key).toBe(undefined);
+      expect(bst.root?.right?.right?.key).toBe('5');
+    }
+
+    const bst = new BST<string, number>();
+    bst.addMany([
+      ['2', 2],
+      ['4', 4],
+      ['5', 5],
+      ['3', 3],
+      ['1', 1]
+    ]);
+    expect(bst.size).toBe(5);
+    expect(bst.root?.key).toBe('3');
+    expect(bst.root?.left?.key).toBe('1');
+    expect(bst.root?.left?.left?.key).toBe(undefined);
+    expect(bst.root?.left?.right?.key).toBe('2');
+    expect(bst.root?.right?.key).toBe('4');
+    expect(bst.root?.right?.left?.key).toBe(undefined);
+    expect(bst.root?.right?.right?.key).toBe('5');
+    bst.delete('3');
+    checkTreeStructure(bst);
+    const cloned = bst.clone();
+    checkTreeStructure(cloned);
+    bst.delete('2');
+    bst.delete('1');
+    bst.delete('4');
+    bst.delete('5');
+    expect(bst.size).toBe(0);
+
+    cloned.delete('1');
+    expect(bst.size).toBe(0);
+    expect(cloned.size).toBe(3);
+    cloned.delete('2');
+    cloned.delete('3');
+    cloned.delete('4');
+    cloned.delete('5');
+    expect(cloned.size).toBe(0);
+  });
 });
 
 describe('BST isBST', function () {
@@ -865,7 +929,7 @@ describe('BST Performance test', function () {
     // expect(bst.lastKey()).toBe(9);
   });
 
-  it('should subTreeTraverse, null should be ignored', () => {
+  it('should dfs as sub tree traversal, null should be ignored', () => {
     const bst = new BST();
     bst.addMany([4, 2, 6, 1, 3, 5, 7]);
     expect(bst.dfs(node => node.key, 'pre', bst.getNode(6), IterationType.ITERATIVE)).toEqual([6, 5, 7]);

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

@@ -138,9 +138,46 @@ describe('RedBlackTree', () => {
       expect(predecessorNode).toBe(tree.getNode(10));
     });
   });
+
+  it('should the clone method', () => {
+    function checkTreeStructure(rbTree: RedBlackTree<string, number>) {
+      expect(rbTree.size).toBe(4);
+      expect(rbTree.root?.key).toBe('2');
+      expect(rbTree.root?.left?.key).toBe('1');
+      expect(rbTree.root?.left?.left?.key).toBe(NaN);
+      expect(rbTree.root?.left?.right?.key).toBe(NaN);
+      expect(rbTree.root?.right?.key).toBe('4');
+      expect(rbTree.root?.right?.left?.key).toBe(NaN);
+      expect(rbTree.root?.right?.right?.key).toBe('5');
+    }
+
+    const rbTree = new RedBlackTree<string, number>();
+    rbTree.addMany([
+      ['2', 2],
+      ['4', 4],
+      ['5', 5],
+      ['3', 3],
+      ['1', 1]
+    ]);
+    expect(rbTree.size).toBe(5);
+    expect(rbTree.root?.key).toBe('2');
+    expect(rbTree.root?.left?.key).toBe('1');
+    expect(rbTree.root?.left?.left?.key).toBe(NaN);
+    expect(rbTree.root?.left?.right?.key).toBe(NaN);
+    expect(rbTree.root?.right?.key).toBe('4');
+    expect(rbTree.root?.right?.left?.key).toBe('3');
+    expect(rbTree.root?.right?.right?.key).toBe('5');
+    rbTree.delete('3');
+    checkTreeStructure(rbTree);
+    const cloned = rbTree.clone();
+    checkTreeStructure(cloned);
+    cloned.delete('1');
+    expect(rbTree.size).toBe(4);
+    expect(cloned.size).toBe(3);
+  });
 });
 
-describe('RedBlackTree', () => {
+describe('RedBlackTree 2', () => {
   let tree: RedBlackTree<number>;
 
   beforeEach(() => {