data-structure-typed 1.54.0 → 1.54.1

package/src/data-structures/graph/directed-graph.ts

@@ -45,6 +45,9 @@ export class DirectedEdge<E = any> extends AbstractEdge<E> {
   }
 }
 
+/**
+ *
+ */
 export class DirectedGraph<
     V = any,
     E = any,

package/src/data-structures/graph/map-graph.ts

@@ -40,6 +40,9 @@ export class MapEdge<E = any> extends DirectedEdge<E> {
   }
 }
 
+/**
+ *
+ */
 export class MapGraph<
   V = any,
   E = any,

package/src/data-structures/graph/undirected-graph.ts

@@ -42,6 +42,9 @@ export class UndirectedEdge<E = number> extends AbstractEdge<E> {
   }
 }
 
+/**
+ *
+ */
 export class UndirectedGraph<
     V = any,
     E = any,

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

@@ -59,6 +59,9 @@ export class SinglyLinkedListNode<E = any> {
   }
 }
 
+/**
+ *
+ */
 export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R, SinglyLinkedList<E, R>> {
   constructor(
     elements: Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>> = [],

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

@@ -19,6 +19,9 @@ export class SkipListNode<K, V> {
   }
 }
 
+/**
+ *
+ */
 export class SkipList<K, V> {
   /**
    * The constructor function initializes a SkipLinkedList object with optional options and elements.

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

@@ -7,6 +7,9 @@
  */
 import type { MatrixOptions } from '../../types';
 
+/**
+ *
+ */
 export class Matrix {
   /**
    * The constructor function initializes a matrix object with the provided data and options, or with

package/src/data-structures/matrix/navigator.ts

@@ -25,6 +25,9 @@ export class Character {
   }
 }
 
+/**
+ *
+ */
 export class Navigator<T = number> {
   onMove: (cur: [number, number]) => void;
   protected readonly _matrix: T[][];

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

@@ -8,6 +8,9 @@
 import type { Comparator, ElementCallback, PriorityQueueOptions } from '../../types';
 import { PriorityQueue } from './priority-queue';
 
+/**
+ *
+ */
 export class MaxPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
   /**
    * The constructor initializes a PriorityQueue with optional elements and options, including a

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

@@ -8,6 +8,9 @@
 import type { Comparator, ElementCallback, PriorityQueueOptions } from '../../types';
 import { PriorityQueue } from './priority-queue';
 
+/**
+ *
+ */
 export class MinPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
   /**
    * The constructor initializes a PriorityQueue with optional elements and options, including a

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

@@ -8,10 +8,6 @@
 import type { ElementCallback, TrieOptions } from '../../types';
 import { IterableElementBase } from '../base';
 
-/**
- * TrieNode represents a node in the Trie data structure. It holds a character key, a map of children nodes,
- * and a flag indicating whether it's the end of a word.
- */
 export class TrieNode {
   constructor(key: string) {
     this._key = key;

package/src/interfaces/binary-tree.ts

@@ -1,30 +1,16 @@
-import { BinaryTree, BinaryTreeNode } from '../data-structures';
-import type {
-  BinaryTreeDeleteResult,
-  BinaryTreeNested,
-  BinaryTreeNodeNested,
-  BinaryTreeOptions,
-  BTNRep,
-  NodePredicate
-} from '../types';
+import { BinaryTreeNode } from '../data-structures';
+import type { BinaryTreeDeleteResult, BinaryTreeOptions, BTNRep, NodePredicate } from '../types';
 
-export interface IBinaryTree<
-  K = any,
-  V = any,
-  R = object,
-  MK = any,
-  MV = any,
-  MR = object,
-  NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNodeNested<K, V>,
-  TREE extends BinaryTree<K, V, R, MK, MV, MR, NODE, TREE> = BinaryTreeNested<K, V, R, MK, MV, MR, NODE>
-> {
-  createNode(key: K, value?: NODE['value']): NODE;
+export interface IBinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = object> {
+  createNode(key: K, value?: BinaryTreeNode['value']): BinaryTreeNode;
 
-  createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): TREE;
+  createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): IBinaryTree<K, V, R, MK, MV, MR>;
 
-  add(keyOrNodeOrEntryOrRawElement: BTNRep<K, V, NODE>, value?: V, count?: number): boolean;
+  add(keyOrNodeOrEntryOrRawElement: BTNRep<K, V, BinaryTreeNode<K, V>>, value?: V, count?: number): boolean;
 
-  addMany(nodes: Iterable<BTNRep<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
+  addMany(nodes: Iterable<BTNRep<K, V, BinaryTreeNode<K, V>>>, values?: Iterable<V | undefined>): boolean[];
 
-  delete(predicate: R | BTNRep<K, V, NODE> | NodePredicate<NODE>): BinaryTreeDeleteResult<NODE>[];
+  delete(
+    predicate: R | BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>
+  ): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[];
 }

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

@@ -0,0 +1,3 @@
+import { AVLTreeOptions } from './avl-tree';
+
+export type AVLTreeCounterOptions<K, V, R> = AVLTreeOptions<K, V, R> & {};

package/src/types/data-structures/binary-tree/avl-tree-multi-map.ts

@@ -1,8 +1,3 @@
-import { AVLTreeMultiMap, AVLTreeMultiMapNode } from '../../../data-structures';
 import type { AVLTreeOptions } from './avl-tree';
 
-export type AVLTreeMultiMapNodeNested<K, V> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, any>>>
-
-export type AVLTreeMultiMapNested<K, V, R, MK, MV, MR, NODE extends AVLTreeMultiMapNode<K, V, NODE>> = AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, any>>>
-
-export type AVLTreeMultiMapOptions<K, V, R> = AVLTreeOptions<K, V, R> & {}
+export type AVLTreeMultiMapOptions<K, V, R> = Omit<AVLTreeOptions<K, V, R>, 'isMapMode'> & {}

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

@@ -1,8 +1,3 @@
-import { AVLTree, AVLTreeNode } from '../../../data-structures';
 import { BSTOptions } from './bst';
 
-export type AVLTreeNodeNested<K, V> = AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, any>>>
-
-export type AVLTreeNested<K, V, R,MK, MV, MR,  NODE extends AVLTreeNode<K, V, NODE>> = AVLTree<K, V, R,MK, MV, MR,  NODE, AVLTree<K, V, R,MK, MV, MR,  NODE, AVLTree<K, V, R,MK, MV, MR,  NODE, any>>>
-
 export type AVLTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};

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

@@ -1,11 +1,6 @@
-import { BinaryTree, BinaryTreeNode } from '../../../data-structures';
 import { IterationType, OptValue } from '../../common';
 import { DFSOperation } from '../../../common';
 
-export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V,  any>>>
-
-export type BinaryTreeNested<K, V, R, MK, MV, MR, NODE extends BinaryTreeNode<K, V, NODE>> = BinaryTree<K, V, R, MK, MV, MR, NODE,BinaryTree<K, V, R, MK, MV, MR, NODE,BinaryTree<K, V, R, MK, MV, MR, NODE,any>>>
-
 export type ToEntryFn<K, V, R> = (rawElement: R) => BTNEntry<K, V>;
 
 export type BinaryTreeOptions<K, V, R> = {

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

@@ -1,10 +1,6 @@
-import { BST, BSTNode } from '../../../data-structures';
 import type { BinaryTreeOptions } from './binary-tree';
 import { Comparable } from '../../utils';
-
-export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, any>>>
-
-export type BSTNested<K, V, R,MK, MV, MR,  NODE extends BSTNode<K, V, NODE>> = BST<K, V, R,MK, MV, MR,  NODE,BST<K, V, R,MK, MV, MR,  NODE,BST<K, V, R,MK, MV, MR,  NODE, any>>>
+import { OptValue } from '../../common';
 
 export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
   specifyComparable?: (key: K) => Comparable
@@ -15,5 +11,9 @@ export type BSTNOptKey<K> = K | undefined;
 
 export type OptNode<NODE> = NODE | undefined;
 
+export type BSTNEntry<K, V> = [BSTNOptKey<K>, OptValue<V>];
+
 export type BSTNOptKeyOrNode<K, NODE> = BSTNOptKey<K> | NODE;
 
+export type BSTNRep<K, V, NODE> = BSTNEntry<K, V> | BSTNOptKeyOrNode<K, NODE>;
+

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

@@ -5,3 +5,5 @@ export * from './segment-tree';
 export * from './avl-tree-multi-map';
 export * from './rb-tree';
 export * from './tree-multi-map';
+export * from './tree-counter';
+export * from './avl-tree-counter';

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

@@ -1,10 +1,5 @@
-import { RedBlackTree, RedBlackTreeNode } from '../../../data-structures';
-import type { BSTOptions } from "./bst";
+import type { BSTOptions } from './bst';
 
 export type RBTNColor = 'RED' | 'BLACK';
 
-export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, any>>>
-
-export type RedBlackTreeNested<K, V, R, MK, MV, MR, NODE extends RedBlackTreeNode<K, V, NODE>> = RedBlackTree<K, V, R, MK, MV, MR, NODE, RedBlackTree<K, V, R, MK, MV, MR, NODE, RedBlackTree<K, V, R, MK, MV, MR, NODE, any>>>
-
 export type RedBlackTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};

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

@@ -0,0 +1,3 @@
+import type { RedBlackTreeOptions } from './rb-tree';
+
+export type TreeCounterOptions<K, V, R> = RedBlackTreeOptions<K, V, R> & {};

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

@@ -1,8 +1,3 @@
-import { TreeMultiMap, TreeMultiMapNode } from '../../../data-structures';
 import type { RedBlackTreeOptions } from './rb-tree';
 
-export type TreeMultiMapNodeNested<K, V> = TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, any>>>
-
-export type TreeMultiMapNested<K, V, R, MK, MV, MR, NODE extends TreeMultiMapNode<K, V, NODE>> = TreeMultiMap<K, V, R, MK, MV, MR, NODE, TreeMultiMap<K, V, R, MK, MV, MR, NODE,TreeMultiMap<K, V, R, MK, MV, MR, NODE, any>>>
-
-export type TreeMultiMapOptions<K, V, R> = RedBlackTreeOptions<K, V, R> & {}
+export type TreeMultiMapOptions<K, V, R> = Omit<RedBlackTreeOptions<K, V, R>, 'isMapMode'> & {}

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

@@ -3,7 +3,7 @@ import { AVLTree } from 'data-structure-typed';
 describe('AVL Tree Test from data-structure-typed', () => {
   it('should perform various operations on a AVL Tree from data-structure-typed', () => {
     const keys = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    const tree = new AVLTree<number>();
+    const tree = new AVLTree<number>([], { isMapMode: false });
 
     for (const i of keys) tree.add([i, i]);
 

package/test/integration/avl-tree.test.ts

@@ -48,7 +48,7 @@ describe('AVL Tree Test', () => {
     expect(lesserSum).toBe(45);
 
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
-    expect(node15?.value).toBe(15);
+    expect(node15?.value).toBe(undefined);
 
     const dfs = tree.dfs(node => node, 'IN');
     expect(dfs[0].key).toBe(1);

package/test/integration/bst.test.ts

@@ -27,7 +27,7 @@ describe('Individual package BST operations test', () => {
     expect(nodeVal9?.key).toBe(undefined);
 
     const nodeVal11 = bst.getNode(node => node.value === 11);
-    expect(nodeVal11?.key).toBe(11);
+    expect(nodeVal11?.key).toBe(undefined);
 
     const leftMost = bst.getLeftMost(node => node);
     expect(leftMost?.key).toBe(1);
@@ -186,7 +186,7 @@ describe('Individual package BST operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<number, { key: number; keyA: number }>();
+    const objBST = new BST<number, { key: number; keyA: number }>([], { isMapMode: false });
     expect(objBST).toBeInstanceOf(BST);
     objBST.add([11, { key: 11, keyA: 11 }]);
     objBST.add([3, { key: 3, keyA: 3 }]);

package/test/integration/compile.js

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

package/test/integration/compile.ts

@@ -0,0 +1,171 @@
+import {
+  AVLTree,
+  BinaryTree,
+  BST,
+  Deque,
+  DoublyLinkedList,
+  HashMap,
+  Heap,
+  MaxPriorityQueue,
+  MinHeap,
+  MinPriorityQueue,
+  Queue,
+  RedBlackTree,
+  SinglyLinkedList,
+  Stack,
+  TreeMultiMap,
+  Trie
+} from 'data-structure-typed';
+
+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