data-structure-typed 1.47.4 → 1.47.6

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

@@ -112,7 +112,7 @@ describe('AVL Tree Test', () => {
 describe('AVL Tree Test recursively', () => {
   it('should perform various operations on a AVL Tree', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    const tree = new AVLTree<number>({ iterationType: IterationType.RECURSIVE });
+    const tree = new AVLTree<number>([], { iterationType: IterationType.RECURSIVE });
 
     for (const i of arr) tree.add(i, i);
 

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

@@ -189,9 +189,9 @@ describe('BinaryTree', () => {
     tree.add(4);
     tree.add(2);
     expect(tree.getHeight()).toBe(1);
-    tree.options.iterationType = IterationType.RECURSIVE;
+    tree.iterationType = IterationType.RECURSIVE;
     expect(tree.getHeight()).toBe(1);
-    tree.options.iterationType = IterationType.ITERATIVE;
+    tree.iterationType = IterationType.ITERATIVE;
 
     tree.add(6);
     tree.add(1);
@@ -381,7 +381,7 @@ describe('BinaryTree', () => {
   let tree: BinaryTree<string>;
 
   beforeEach(() => {
-    tree = new BinaryTree<string>({ iterationType: IterationType.RECURSIVE });
+    tree = new BinaryTree<string>([], { iterationType: IterationType.RECURSIVE });
   });
 
   afterEach(() => {
@@ -541,11 +541,11 @@ describe('BinaryTree', () => {
     tree.add(3, 'B');
     tree.add(7, 'C');
 
-    tree.options.iterationType = IterationType.ITERATIVE;
+    tree.iterationType = IterationType.ITERATIVE;
     expect([...tree]).toEqual([[3, "B"], [5, "A"], [7, "C"]]);
-    tree.options.iterationType = IterationType.RECURSIVE;
+    tree.iterationType = IterationType.RECURSIVE;
     expect([...tree]).toEqual([[3, "B"], [5, "A"], [7, "C"]]);
-    tree.options.iterationType = IterationType.ITERATIVE;
+    tree.iterationType = IterationType.ITERATIVE;
 
     const result = tree.morris();
     expect(result).toEqual([3, 5, 7]);

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

@@ -395,7 +395,7 @@ describe('BST operations test', () => {
 
 describe('BST operations test recursively', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
-    const bst = new BST({ iterationType: IterationType.RECURSIVE });
+    const bst = new BST([], { iterationType: IterationType.RECURSIVE });
     expect(bst).toBeInstanceOf(BST);
     bst.add(11, 11);
     bst.add(3, 3);

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

@@ -245,7 +245,7 @@ describe('TreeMultimap operations test', () => {
 
 describe('TreeMultimap operations test recursively', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
-    const treeMultimap = new TreeMultimap({ iterationType: IterationType.RECURSIVE });
+    const treeMultimap = new TreeMultimap([], { iterationType: IterationType.RECURSIVE });
 
     expect(treeMultimap instanceof TreeMultimap);
     treeMultimap.add(11, 11);

package/test/unit/data-structures/hash/hash-table.test.ts

@@ -8,7 +8,7 @@ describe('HashNode', () => {
 
     expect(hashNode.key).toBe(key);
     expect(hashNode.value).toBe(value);
-    expect(hashNode.next).toBe(null);
+    expect(hashNode.next).toBe(undefined);
   });
 });
 
@@ -16,7 +16,7 @@ describe('HashTable', () => {
   it('should initialize with default capacity', () => {
     const hashTable = new HashTable<string, string>();
     expect(hashTable.capacity).toBe(16);
-    expect(hashTable.buckets).toEqual(new Array(16).fill(null));
+    expect(hashTable.buckets).toEqual(new Array(16).fill(undefined));
     expect(hashTable.hashFn('a')).toBe(6);
     expect(hashTable.capacity).toBe(16);
     expect(hashTable.size).toBe(0);
@@ -184,3 +184,59 @@ describe('HashTable performance', function () {
     }
   });
 });
+
+
+describe('HashTable methods', () => {
+  let hashTable: HashTable<string, string>;
+
+  beforeEach(() => {
+    hashTable = new HashTable();
+    for (let i = 0; i < 10; i++) {
+      hashTable.set(`key${i}`, `value${i}`);
+    }
+  });
+
+  test('should retrieve correct values with get method', () => {
+    for (let i = 0; i < 10; i++) {
+      expect(hashTable.get(`key${i}`)).toBe(`value${i}`);
+    }
+  });
+
+  // test('forEach should apply a function to each key-value pair', () => {
+  //   const mockCallback = jest.fn();
+  //   hashTable.forEach(mockCallback);
+  //
+  //   expect(mockCallback.mock.calls.length).toBe(10);
+  //   for (let i = 0; i < 10; i++) {
+  //     // Check whether each key-value pair has been called before, regardless of the order
+  //     const call = mockCallback.mock.calls.find(call => call[1] === `value${i}`);
+  //     expect(call).toBeTruthy();
+  //     expect(call[0]).toBe(`key${i}`);
+  //   }
+  // });
+
+
+  test('filter should return a new HashTable with elements that satisfy the condition', () => {
+    const filtered = hashTable.filter(([key]) => key.endsWith('1') || key.endsWith('3'));
+
+    expect(filtered.size).toBe(2);
+    expect(filtered.get('key1')).toBe('value1');
+    expect(filtered.get('key3')).toBe('value3');
+  });
+
+  test('map should return a new HashTable with mapped values', () => {
+    const mapped = hashTable.map(([, value]) => value.toUpperCase());
+
+    for (let i = 0; i < 10; i++) {
+      expect(mapped.get(`key${i}`)).toBe(`value${i}`.toUpperCase());
+    }
+  });
+
+  test('reduce should accumulate values based on the reducer function', () => {
+    const result = hashTable.reduce((acc, [, value]) => `${acc}-${value}`, '');
+
+    expect(result).toBe('-value5-value7-value3-value4-value6-value0-value2-value8-value1-value9');
+  });
+
+});
+

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

@@ -23,7 +23,7 @@ describe('Heap Operation Test', () => {
   });
 
   it('should object heap work well', function () {
-    const minHeap = new MinHeap<{ a: string; key: number }>({ comparator: (a, b) => a.key - b.key });
+    const minHeap = new MinHeap<{ a: string; key: number }>([], { comparator: (a, b) => a.key - b.key });
     minHeap.add({ key: 1, a: 'a1' });
     minHeap.add({ key: 6, a: 'a6' });
     minHeap.add({ key: 2, a: 'a2' });
@@ -43,7 +43,7 @@ describe('Heap Operation Test', () => {
       i++;
     }
 
-    const maxHeap = new MaxHeap<{ key: number; a: string }>({ comparator: (a, b) => b.key - a.key });
+    const maxHeap = new MaxHeap<{ key: number; a: string }>([], { comparator: (a, b) => b.key - a.key });
     maxHeap.add({ key: 1, a: 'a1' });
     maxHeap.add({ key: 6, a: 'a6' });
     maxHeap.add({ key: 5, a: 'a5' });

package/test/unit/data-structures/heap/max-heap.test.ts

@@ -5,7 +5,7 @@ describe('MaxHeap', () => {
   let maxHeap: MaxHeap<number>;
 
   beforeEach(() => {
-    maxHeap = new MaxHeap({ comparator: numberComparator });
+    maxHeap = new MaxHeap([], { comparator: numberComparator });
   });
 
   it('add and poll elements in descending order', () => {

package/test/unit/data-structures/heap/min-heap.test.ts

@@ -5,7 +5,7 @@ describe('MinHeap', () => {
   let minHeap: MinHeap<number>;
 
   beforeEach(() => {
-    minHeap = new MinHeap({ comparator: numberComparator });
+    minHeap = new MinHeap([], { comparator: numberComparator });
   });
 
   it('add and poll elements in ascending order', () => {
@@ -49,4 +49,52 @@ describe('MinHeap', () => {
     minHeap.poll();
     expect(minHeap.isEmpty()).toBe(true);
   });
+
+
+  const n = 100000;
+
+  it('should push & dfs', () => {
+    for (let i = 0; i < n; i++) {
+      minHeap.push(i);
+    }
+    expect(minHeap.dfs()[0]).toBe(0)
+    expect(minHeap.dfs()[999]).toBe(4126)
+  });
+
+});
+
+describe('Heap iterative methods', () => {
+  let heap: MinHeap<number>;
+
+  beforeEach(() => {
+    heap = new MinHeap<number>();
+    for (let i = 1; i <= 10; i++) {
+      heap.add(i * 10); // Add 10, 20, ..., 100
+    }
+  });
+
+  test('Heap is iterable', () => {
+    expect([...heap]).toEqual([10, 20, 30, 40, 50, 60, 70, 80, 90, 100]);
+  });
+
+  test('forEach method calls a function for each element', () => {
+    const mockCallback = jest.fn();
+    heap.forEach(mockCallback);
+    expect(mockCallback.mock.calls.length).toBe(10);
+  });
+
+  test('filter method returns filtered elements', () => {
+    const result = heap.filter(x => x > 50);
+    expect([...result]).toEqual([60, 70, 80, 90, 100]);
+  });
+
+  test('map method correctly maps elements', () => {
+    const result = heap.map(x => x / 10, (a: number, b: number) => a - b);
+    expect([...result]).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+  });
+
+  test('reduce method correctly reduces elements', () => {
+    const result = heap.reduce((acc, curr) => acc + curr, 0);
+    expect(result).toBe(550); // 10+20+...+100 = 550
+  });
 });

package/test/unit/data-structures/linked-list/doubly-linked-list.test.ts

@@ -166,7 +166,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.reverse();
 
     expect(list.toArray()).toEqual([3, 2, 1]);
-    expect(list.toArrayBackward()).toEqual([1, 2, 3]);
+    expect(list.toReversedArray()).toEqual([1, 2, 3]);
   });
 
   it('should map elements using a callback function', () => {
@@ -268,7 +268,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const reversedArray = list.toArrayBackward();
+    const reversedArray = list.toReversedArray();
 
     expect(reversedArray).toEqual([3, 2, 1]);
   });

package/test/unit/data-structures/priority-queue/max-priority-queue.test.ts

@@ -16,7 +16,7 @@ describe('MaxPriorityQueue Operation Test', () => {
   });
 
   it('should add elements and maintain heap property in a object MaxPriorityQueue', () => {
-    const priorityQueue = new MaxPriorityQueue<{ keyA: number }>({ comparator: (a, b) => b.keyA - a.keyA });
+    const priorityQueue = new MaxPriorityQueue<{ keyA: number }>([], { comparator: (a, b) => b.keyA - a.keyA });
     priorityQueue.refill([{ keyA: 5 }, { keyA: 3 }, { keyA: 1 }]);
     priorityQueue.add({ keyA: 7 });
 
@@ -52,7 +52,7 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an array', () => {
     const array = [5, 3, 7, 1];
-    const heap = MaxPriorityQueue.heapify<number>({ elements: array, comparator: (a, b) => b - a });
+    const heap = MaxPriorityQueue.heapify<number>(array, { comparator: (a, b) => b - a });
     heap.refill(array);
 
     expect(heap.poll()).toBe(7);
@@ -63,7 +63,8 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an object array', () => {
     const elements = [{ keyA: 5 }, { keyA: 3 }, { keyA: 7 }, { keyA: 1 }];
-    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>({ elements, comparator: (a, b) => b.keyA - a.keyA });
+    debugger
+    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>(elements, { comparator: (a, b) => b.keyA - a.keyA });
 
     expect(maxPQ.poll()?.keyA).toBe(7);
     expect(maxPQ.poll()?.keyA).toBe(5);

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

@@ -5,7 +5,7 @@ import { isDebugTest } from '../../../config';
 const isDebug = isDebugTest;
 describe('PriorityQueue Operation Test', () => {
   it('should PriorityQueue poll, pee, heapify, toArray work well', function () {
-    const minPQ = new PriorityQueue<number>({ comparator: (a, b) => a - b });
+    const minPQ = new PriorityQueue<number>([], { comparator: (a, b) => a - b });
     minPQ.refill([5, 2, 3, 4, 6, 1]);
     expect(minPQ.toArray()).toEqual([1, 2, 3, 4, 6, 5]);
     minPQ.poll();
@@ -14,15 +14,14 @@ describe('PriorityQueue Operation Test', () => {
     expect(minPQ.toArray()).toEqual([4, 5, 6]);
     expect(minPQ.peek()).toBe(4);
     expect(
-      PriorityQueue.heapify({
-        elements: [3, 2, 1, 5, 6, 7, 8, 9, 10],
+      PriorityQueue.heapify([3, 2, 1, 5, 6, 7, 8, 9, 10], {
         comparator: (a, b) => a - b
       }).toArray()
-    ).toEqual([1, 2, 3, 5, 6, 7, 8, 9, 10]);
+    ).toEqual([1, 3, 2, 5, 6, 7, 8, 9, 10]);
   });
 
   it('should Max PriorityQueue poll, peek, heapify, toArray work well', function () {
-    const maxPriorityQueue = new PriorityQueue<number>({ comparator: (a, b) => b - a });
+    const maxPriorityQueue = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
     maxPriorityQueue.refill([5, 2, 3, 4, 6, 1]);
     expect(maxPriorityQueue.toArray()).toEqual([6, 5, 3, 4, 2, 1]);
     maxPriorityQueue.poll();
@@ -31,15 +30,15 @@ describe('PriorityQueue Operation Test', () => {
     expect(maxPriorityQueue.toArray()).toEqual([3, 2, 1]);
     expect(maxPriorityQueue.peek()).toBe(3);
     expect(
-      PriorityQueue.heapify({
-        elements: [3, 2, 1, 5, 6, 7, 8, 9, 10],
+      PriorityQueue.heapify([3, 2, 1, 5, 6, 7, 8, 9, 10], {
+
         comparator: (a, b) => a - b
       }).toArray()
-    ).toEqual([1, 2, 3, 5, 6, 7, 8, 9, 10]);
+    ).toEqual([1, 3, 2, 5, 6, 7, 8, 9, 10]);
   });
 
   it('should PriorityQueue clone, sort, getNodes, dfs work well', function () {
-    const minPQ1 = new PriorityQueue<number>({ comparator: (a, b) => a - b });
+    const minPQ1 = new PriorityQueue<number>([], { comparator: (a, b) => a - b });
     minPQ1.refill([2, 5, 8, 3, 1, 6, 7, 4]);
     const clonedPriorityQueue = minPQ1.clone();
     expect(clonedPriorityQueue.elements).toEqual(minPQ1.elements);
@@ -52,7 +51,7 @@ describe('PriorityQueue Operation Test', () => {
 
 describe('Priority Queue Performance Test', () => {
   it('should numeric heap work well', function () {
-    const pq = new PriorityQueue({ comparator: (a, b) => b - a });
+    const pq = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
 
     const tS = performance.now();
 

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

@@ -205,3 +205,40 @@ describe('Queue Performance Test', () => {
     expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
   });
 });
+
+
+describe('Queue iterative methods', () => {
+  let queue: Queue<number>;
+
+  beforeEach(() => {
+    queue = new Queue();
+    for (let i = 0; i < 10; i++) {
+      queue.enqueue(i);
+    }
+  });
+
+  test('iterator should provide access to all elements', () => {
+    const elements = [];
+    for (const item of queue) {
+      elements.push(item);
+    }
+    expect(elements).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+  });
+
+  test('forEach should apply the callback to each element', () => {
+    const elements: number[] = [];
+    queue.forEach((element) => elements.push(element * 2));
+    expect(elements).toEqual([0, 2, 4, 6, 8, 10, 12, 14, 16, 18]);
+  });
+
+  test('filter should return a new queue with only the elements that satisfy the predicate', () => {
+    const filteredQueue = queue.filter(element => element % 2 === 0);
+    expect([...filteredQueue]).toEqual([0, 2, 4, 6, 8]);
+  });
+
+  test('map should return a new queue with the transformed elements', () => {
+    const mappedQueue = queue.map(element => element * 2);
+    expect([...mappedQueue]).toEqual([0, 2, 4, 6, 8, 10, 12, 14, 16, 18]);
+  });
+
+});

package/test/unit/data-structures/stack/stack.test.ts

@@ -15,7 +15,7 @@ describe('Stack', () => {
     stack.push(1);
     stack.push(2);
     stack.push(3);
-    expect(stack.size()).toBe(3);
+    expect(stack.size).toBe(3);
   });
 
   it('should peek at the top element without removing it', () => {
@@ -23,7 +23,7 @@ describe('Stack', () => {
     stack.push(2);
     stack.push(3);
     expect(stack.peek()).toBe(3);
-    expect(stack.size()).toBe(3);
+    expect(stack.size).toBe(3);
   });
 
   it('should pop elements from the stack', () => {
@@ -32,7 +32,7 @@ describe('Stack', () => {
     stack.push(3);
     const poppedElement = stack.pop();
     expect(poppedElement).toBe(3);
-    expect(stack.size()).toBe(2);
+    expect(stack.size).toBe(2);
   });
 
   it('should return null when popping from an empty stack', () => {
@@ -53,7 +53,7 @@ describe('Stack', () => {
     stack.push(2);
     stack.push(3);
     stack.clear();
-    expect(stack.size()).toBe(0);
+    expect(stack.size).toBe(0);
     expect(stack.isEmpty()).toBe(true);
   });
 
@@ -61,7 +61,57 @@ describe('Stack', () => {
     stack.push(1);
     stack.push(2);
     const clonedStack = stack.clone();
-    expect(clonedStack.size()).toBe(2);
+    expect(clonedStack.size).toBe(2);
     expect(clonedStack.pop()).toBe(2);
   });
 });
+
+
+describe('Stack iterative methods', () => {
+  let stack: Stack<number>; // Declare a Stack instance
+
+  beforeEach(() => {
+    stack = new Stack<number>(); // Create a new Stack instance before each test
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+  });
+
+  test('should iterate through the stack', () => {
+    const result: number[] = [];
+    for (const element of stack) {
+      result.push(element);
+    }
+
+    expect(result).toEqual([1, 2, 3]); // iteration should start from the top of the stack
+  });
+
+  test('should apply forEach to the stack', () => {
+    const result: number[] = [];
+    stack.forEach((element) => {
+      result.push(element);
+    });
+
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  test('should filter elements in the stack', () => {
+    const filteredStack = stack.filter((element) => element > 1);
+
+    expect(filteredStack.size).toBe(2);
+    expect([...filteredStack]).toEqual([2, 3]);
+  });
+
+  test('should map elements in the stack', () => {
+    const mappedStack = stack.map((element) => element * 2);
+
+    expect(mappedStack.size).toBe(3);
+    expect([...mappedStack]).toEqual([2, 4, 6]);
+  });
+
+  test('should reduce elements in the stack', () => {
+    const sum = stack.reduce((accumulator, element) => accumulator + element, 0);
+
+    expect(sum).toBe(6);
+  });
+});

package/test/unit/data-structures/trie/trie.test.ts

@@ -823,3 +823,36 @@ describe('Trie operations', () => {
     expect(trie.getHeight()).toBe(6); // Assuming 'apple' and 'banana' are the longest words.
   });
 });
+
+describe('Trie class', () => {
+  let trie: Trie;
+  beforeEach(() => {
+    trie = new Trie(['apple', 'app', 'banana', 'band', 'bandana']);
+  });
+
+  test('[Symbol.iterator] should iterate over all words', () => {
+    const words = [...trie];
+    expect(words).toEqual(['app', 'apple', 'banana', 'band', 'bandana']);
+  });
+
+  test('forEach should execute a callback for each word', () => {
+    const mockCallback = jest.fn();
+    trie.forEach(mockCallback);
+    expect(mockCallback).toHaveBeenCalledTimes(5);
+  });
+
+  test('filter should return words that satisfy the predicate', () => {
+    const filteredWords = trie.filter(word => word.startsWith('ba'));
+    expect(filteredWords).toEqual(['banana', 'band', 'bandana']);
+  });
+
+  test('map should apply a function to each word', () => {
+    const mappedWords = trie.map(word => word.length.toString());
+    expect([...mappedWords]).toEqual(['3', '5', '6', '4', '7']);
+  });
+
+  test('reduce should reduce the words to a single value', () => {
+    const concatenatedWords = trie.reduce((acc, word) => acc + word, '');
+    expect(concatenatedWords).toEqual('appapplebananabandbandana');
+  });
+});

package/test/unit/unrestricted-interconversion.test.ts

@@ -0,0 +1,100 @@
+import {
+  AVLTree,
+  BinaryTree,
+  BST,
+  Deque,
+  DoublyLinkedList,
+  MaxHeap,
+  MaxPriorityQueue,
+  MinHeap,
+  MinPriorityQueue,
+  Queue,
+  RedBlackTree,
+  SinglyLinkedList,
+  Stack,
+  TreeMultimap
+} from '../../src';
+import { isDebugTest } from "../config";
+
+const isDebug = isDebugTest;
+const orgArr: number[] = [6, 1, 2, 7, 5, 3, 4, 9, 8];
+const entries: [number, number][] = [[6, 6], [1, 1], [2, 2], [7, 7], [5, 5], [3, 3], [4, 4], [9, 9], [8, 8]];
+
+describe('conversions', () => {
+  it('Array to Queue', () => {
+    const q = new Queue<number>(orgArr);
+    isDebug && q.print();
+  })
+
+  it('Array to Deque', () => {
+    const dq = new Deque<number>(orgArr);
+    isDebug && dq.print();
+  })
+
+  it('Array to SinglyLinkedList', () => {
+    const sl = new SinglyLinkedList<number>(orgArr);
+    isDebug && sl.print();
+  })
+
+  it('Array to DoublyLinkedList', () => {
+    const dl = new DoublyLinkedList<number>(orgArr);
+    isDebug && dl.print();
+  })
+
+  it('Array to Stack', () => {
+    const stack = new Stack<number>(orgArr);
+    isDebug && stack.print();
+  })
+
+  it('Array to MinHeap', () => {
+    const minHeap = new MinHeap<number>(orgArr);
+    isDebug && minHeap.print();
+  })
+
+  it('Array to MaxHeap', () => {
+    const maxHeap = new MaxHeap<number>(orgArr);
+    isDebug && maxHeap.print();
+  })
+
+  it('Array to MinPriorityQueue', () => {
+    const minPQ = new MinPriorityQueue<number>(orgArr);
+    isDebug && minPQ.print();
+  })
+
+  it('Array to MaxPriorityQueue', () => {
+    const maxPQ = new MaxPriorityQueue<number>(orgArr);
+    isDebug && maxPQ.print();
+  })
+
+  it('Entry Array to BinaryTree', () => {
+    const biTree = new BinaryTree<number>(entries);
+    isDebug && biTree.print();
+  })
+
+  it('Entry Array to BST', () => {
+    const bst = new BST<number>(orgArr);
+    expect(bst.size).toBe(9)
+    isDebug && bst.print();
+  })
+
+  it('Entry Array to RedBlackTree', () => {
+    const rbTree = new RedBlackTree<number>(orgArr);
+    expect(rbTree.size).toBe(9)
+    isDebug && rbTree.print();
+  })
+
+  it('Entry Array to AVLTree', () => {
+    const avl = new AVLTree<number>(orgArr);
+    expect(avl.size).toBe(9)
+    isDebug && avl.print();
+  })
+
+  it('Entry Array to TreeMultimap', () => {
+    const treeMulti = new TreeMultimap<number>(orgArr);
+    expect(treeMulti.size).toBe(9)
+    isDebug && treeMulti.print();
+  })
+})
+
+
+