data-structure-typed 1.36.0 → 1.36.2

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

@@ -14,18 +14,15 @@ import type {
 } from '../../types';
 import {CP, LoopType} from '../../types';
 import {BinaryTree, BinaryTreeNode} from './binary-tree';
-import {IBST, IBSTNode} from '../../interfaces';
+import {IBinaryTree} from '../../interfaces';
 
-export class BSTNode<V = any, NEIGHBOR extends BSTNode<V, NEIGHBOR> = BSTNodeNested<V>>
-  extends BinaryTreeNode<V, NEIGHBOR>
-  implements IBSTNode<V, NEIGHBOR>
-{
+export class BSTNode<V = any, FAMILY extends BSTNode<V, FAMILY> = BSTNodeNested<V>> extends BinaryTreeNode<V, FAMILY> {
   constructor(key: BinaryTreeNodeKey, val?: V) {
     super(key, val);
   }
 }
 
-export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N> implements IBST<N> {
+export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N> implements IBinaryTree<N> {
   /**
    * The constructor function initializes a binary search tree object with an optional comparator function.
    * @param {BSTOptions} [options] - An optional object that contains configuration options for the binary search tree.

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

@@ -1,12 +1,7 @@
-export * from './abstract-binary-tree';
 export * from './binary-tree';
 export * from './bst';
 export * from './binary-indexed-tree';
 export * from './segment-tree';
 export * from './avl-tree';
-export * from './b-tree';
 export * from './rb-tree';
-export * from './splay-tree';
-export * from './aa-tree';
 export * from './tree-multiset';
-export * from './two-three-tree';

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

@@ -1,11 +1,11 @@
 import {BinaryTreeNodeKey, RBColor, RBTreeNodeNested, RBTreeOptions} from '../../types';
-import {IRBTree, IRBTreeNode} from '../../interfaces';
+import {IBinaryTree} from '../../interfaces';
 import {BST, BSTNode} from './bst';
 
-export class RBTreeNode<V = any, NEIGHBOR extends RBTreeNode<V, NEIGHBOR> = RBTreeNodeNested<V>>
-  extends BSTNode<V, NEIGHBOR>
-  implements IRBTreeNode<V, NEIGHBOR>
-{
+export class RBTreeNode<V = any, FAMILY extends RBTreeNode<V, FAMILY> = RBTreeNodeNested<V>> extends BSTNode<
+  V,
+  FAMILY
+> {
   private _color: RBColor;
 
   constructor(key: BinaryTreeNodeKey, val?: V) {
@@ -22,7 +22,7 @@ export class RBTreeNode<V = any, NEIGHBOR extends RBTreeNode<V, NEIGHBOR> = RBTr
   }
 }
 
-export class RBTree<N extends RBTreeNode<N['val'], N> = RBTreeNode> extends BST<N> implements IRBTree<N> {
+export class RBTree<N extends RBTreeNode<N['val'], N> = RBTreeNode> extends BST<N> implements IBinaryTree<N> {
   constructor(options?: RBTreeOptions) {
     super(options);
   }

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

@@ -7,13 +7,13 @@
  */
 import type {BinaryTreeNodeKey, TreeMultisetNodeNested, TreeMultisetOptions} from '../../types';
 import {BinaryTreeDeletedResult, CP, DFSOrderPattern, FamilyPosition, LoopType} from '../../types';
-import {ITreeMultiset, ITreeMultisetNode} from '../../interfaces';
+import {IBinaryTree} from '../../interfaces';
 import {AVLTree, AVLTreeNode} from './avl-tree';
 
-export class TreeMultisetNode<V = any, NEIGHBOR extends TreeMultisetNode<V, NEIGHBOR> = TreeMultisetNodeNested<V>>
-  extends AVLTreeNode<V, NEIGHBOR>
-  implements ITreeMultisetNode<V, NEIGHBOR>
-{
+export class TreeMultisetNode<
+  V = any,
+  FAMILY extends TreeMultisetNode<V, FAMILY> = TreeMultisetNodeNested<V>
+> extends AVLTreeNode<V, FAMILY> {
   /**
    * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
    * @param {BinaryTreeNodeKey} key - The `key` parameter is of type `BinaryTreeNodeKey` and represents the unique identifier
@@ -37,7 +37,7 @@ export class TreeMultisetNode<V = any, NEIGHBOR extends TreeMultisetNode<V, NEIG
  */
 export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultisetNode>
   extends AVLTree<N>
-  implements ITreeMultiset<N>
+  implements IBinaryTree<N>
 {
   /**
    * The constructor function for a TreeMultiset class in TypeScript, which extends another class and sets an option to

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

@@ -8,7 +8,7 @@
 import {arrayRemove, uuidV4} from '../../utils';
 import {PriorityQueue} from '../priority-queue';
 import type {DijkstraResult, VertexKey} from '../../types';
-import {IAbstractGraph} from '../../interfaces';
+import {IGraph} from '../../interfaces';
 
 export abstract class AbstractVertex<V = any> {
   /**
@@ -104,7 +104,7 @@ export abstract class AbstractEdge<V = any> {
 export abstract class AbstractGraph<
   V extends AbstractVertex<any> = AbstractVertex<any>,
   E extends AbstractEdge<any> = AbstractEdge<any>
-> implements IAbstractGraph<V, E>
+> implements IGraph<V, E>
 {
   private _vertices: Map<VertexKey, V> = new Map<VertexKey, V>();
 

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

@@ -8,7 +8,7 @@
 import {arrayRemove} from '../../utils';
 import {AbstractEdge, AbstractGraph, AbstractVertex} from './abstract-graph';
 import type {TopologicalStatus, VertexKey} from '../../types';
-import {IDirectedGraph} from '../../interfaces';
+import {IGraph} from '../../interfaces';
 
 export class DirectedVertex<V = any> extends AbstractVertex<V> {
   /**
@@ -64,7 +64,7 @@ export class DirectedEdge<V = any> extends AbstractEdge<V> {
 
 export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E extends DirectedEdge<any> = DirectedEdge>
   extends AbstractGraph<V, E>
-  implements IDirectedGraph<V, E>
+  implements IGraph<V, E>
 {
   /**
    * The constructor function initializes an instance of a class.

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

@@ -126,7 +126,7 @@ export class MapGraph<V extends MapVertex<V['val']> = MapVertex, E extends MapEd
    * If the weight is not provided, it can be set to a default value or left undefined.
    * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type,
    * depending on the specific implementation of the `MapEdge` class.
-   * @returns a new instance of the `MapEdge` class, casted as type `E`.
+   * @returns a new instance of the `MapEdge` class, cast as type `E`.
    */
   override createEdge(src: VertexKey, dest: VertexKey, weight?: number, val?: E['val']): E {
     return new MapEdge(src, dest, weight, val) as E;

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

@@ -8,7 +8,7 @@
 import {arrayRemove} from '../../utils';
 import {AbstractEdge, AbstractGraph, AbstractVertex} from './abstract-graph';
 import type {VertexKey} from '../../types';
-import {IUNDirectedGraph} from '../../interfaces';
+import {IGraph} from '../../interfaces';
 
 export class UndirectedVertex<V = any> extends AbstractVertex<V> {
   /**
@@ -55,7 +55,7 @@ export class UndirectedGraph<
     E extends UndirectedEdge<any> = UndirectedEdge
   >
   extends AbstractGraph<V, E>
-  implements IUNDirectedGraph<V, E>
+  implements IGraph<V, E>
 {
   /**
    * The constructor initializes a new Map object to store edges.

package/src/data-structures/hash/index.ts

@@ -1,7 +1,6 @@
 export * from './hash-table';
 export * from './coordinate-map';
 export * from './coordinate-set';
-export * from './pair';
 export * from './tree-map';
 export * from './tree-set';
 export * from './hash-map';

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

@@ -1,18 +1,17 @@
 /**
  * data-structure-typed
- *
  * @author Kirk Qi
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
 
-import type {CompareFunction} from '../../types';
+import type {HeapComparator, HeapDFSOrderPattern} from '../../types';
 
-export class Heap<T> {
-  private nodes: T[] = [];
-  private readonly comparator: CompareFunction<T>;
+export class Heap<E> {
+  protected nodes: E[] = [];
+  private readonly comparator: HeapComparator<E>;
 
-  constructor(comparator: CompareFunction<T>) {
+  constructor(comparator: HeapComparator<E>) {
     this.comparator = comparator;
   }
 
@@ -20,7 +19,7 @@ export class Heap<T> {
    * Insert an element into the heap and maintain the heap properties.
    * @param value - The element to be inserted.
    */
-  add(value: T): Heap<T> {
+  add(value: E): Heap<E> {
     this.nodes.push(value);
     this.bubbleUp(this.nodes.length - 1);
     return this;
@@ -30,16 +29,16 @@ export class Heap<T> {
    * Remove and return the top element (smallest or largest element) from the heap.
    * @returns The top element or null if the heap is empty.
    */
-  poll(): T | null {
+  poll(): E | null {
     if (this.nodes.length === 0) {
       return null;
     }
     if (this.nodes.length === 1) {
-      return this.nodes.pop() as T;
+      return this.nodes.pop() as E;
     }
 
     const topValue = this.nodes[0];
-    this.nodes[0] = this.nodes.pop() as T;
+    this.nodes[0] = this.nodes.pop() as E;
     this.sinkDown(0);
     return topValue;
   }
@@ -99,7 +98,7 @@ export class Heap<T> {
    * Peek at the top element of the heap without removing it.
    * @returns The top element or null if the heap is empty.
    */
-  peek(): T | null {
+  peek(): E | null {
     if (this.nodes.length === 0) {
       return null;
     }
@@ -117,7 +116,7 @@ export class Heap<T> {
    * Get the last element in the heap, which is not necessarily a leaf node.
    * @returns The last element or null if the heap is empty.
    */
-  leaf(): T | null {
+  get leaf(): E | null {
     return this.nodes[this.size - 1] ?? null;
   }
 
@@ -129,11 +128,18 @@ export class Heap<T> {
     return this.size === 0;
   }
 
+  /**
+   * Reset the nodes of the heap. Make the nodes empty.
+   */
   clear() {
     this.nodes = [];
   }
 
-  refill(nodes: T[]) {
+  /**
+   * Clear and add nodes of the heap
+   * @param nodes
+   */
+  refill(nodes: E[]) {
     this.nodes = nodes;
     this.fix();
   }
@@ -143,41 +149,17 @@ export class Heap<T> {
    * @param value - the element to check.
    * @returns Returns true if the specified element is contained; otherwise, returns false.
    */
-  has(value: T): boolean {
+  has(value: E): boolean {
     return this.nodes.includes(value);
   }
 
-  /**
-   * Use a comparison function to find the index of an element in the heap.
-   * @param value - the element to find.
-   * @param index - the index currently being searched.
-   * @returns The index of the element, or -1 if not found.
-   */
-  private findIndex(value: T, index: number): number {
-    if (index >= this.size) {
-      return -1;
-    }
-
-    const compareResult = this.comparator(value, this.nodes[index]);
-
-    if (compareResult === 0) {
-      return index; // Element found
-    } else if (compareResult < 0) {
-      // The element should be in the left subtree
-      return this.findIndex(value, 2 * index + 1);
-    } else {
-      // The element should be in the right subtree
-      return this.findIndex(value, 2 * index + 2);
-    }
-  }
-
   /**
    * Depth-first search (DFS) method, different traversal orders can be selected。
    * @param order - Traversal order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
    * @returns An array containing elements traversed in the specified order.
    */
-  dfs(order: 'in' | 'pre' | 'post'): T[] {
-    const result: T[] = [];
+  dfs(order: HeapDFSOrderPattern): E[] {
+    const result: E[] = [];
 
     // Auxiliary recursive function, traverses the binary heap according to the traversal order
     const dfsHelper = (index: number) => {
@@ -207,11 +189,11 @@ export class Heap<T> {
    * Convert the heap to an array.
    * @returns An array containing the elements of the heap.
    */
-  toArray(): T[] {
+  toArray(): E[] {
     return [...this.nodes];
   }
 
-  getNodes(): T[] {
+  getNodes(): E[] {
     return this.nodes;
   }
 
@@ -219,8 +201,8 @@ export class Heap<T> {
    * Clone the heap, creating a new heap with the same elements.
    * @returns A new Heap instance containing the same elements.
    */
-  clone(): Heap<T> {
-    const clonedHeap = new Heap<T>(this.comparator);
+  clone(): Heap<E> {
+    const clonedHeap = new Heap<E>(this.comparator);
     clonedHeap.nodes = [...this.nodes];
     return clonedHeap;
   }
@@ -229,8 +211,8 @@ export class Heap<T> {
    * Sort the elements in the heap and return them as an array.
    * @returns An array containing the elements sorted in ascending order.
    */
-  sort(): T[] {
-    const visitedNode: T[] = [];
+  sort(): E[] {
+    const visitedNode: E[] = [];
     const cloned = this.clone();
     while (cloned.size !== 0) {
       const top = cloned.poll();
@@ -245,8 +227,8 @@ export class Heap<T> {
    * @param comparator - Comparison function.
    * @returns A new Heap instance.
    */
-  static heapify<T>(nodes: T[], comparator: CompareFunction<T>): Heap<T> {
-    const binaryHeap = new Heap<T>(comparator);
+  static heapify<E>(nodes: E[], comparator: HeapComparator<E>): Heap<E> {
+    const binaryHeap = new Heap<E>(comparator);
     binaryHeap.nodes = [...nodes];
     binaryHeap.fix(); // Fix heap properties
     return binaryHeap;

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

@@ -7,11 +7,11 @@
  */
 
 import {Heap} from './heap';
-import type {CompareFunction} from '../../types';
+import type {HeapComparator} from '../../types';
 
-export class MaxHeap<T = any> extends Heap<T> {
+export class MaxHeap<E = any> extends Heap<E> {
   constructor(
-    comparator: CompareFunction<T> = (a: T, b: T) => {
+    comparator: HeapComparator<E> = (a: E, b: E) => {
       if (!(typeof a === 'number' && typeof b === 'number')) {
         throw new Error('The a, b params of compare function must be number');
       } else {

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

@@ -7,11 +7,11 @@
  */
 
 import {Heap} from './heap';
-import type {CompareFunction} from '../../types';
+import type {HeapComparator} from '../../types';
 
-export class MinHeap<T = any> extends Heap<T> {
+export class MinHeap<E = any> extends Heap<E> {
   constructor(
-    comparator: CompareFunction<T> = (a: T, b: T) => {
+    comparator: HeapComparator<E> = (a: E, b: E) => {
       if (!(typeof a === 'number' && typeof b === 'number')) {
         throw new Error('The a, b params of compare function must be number');
       } else {

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

@@ -6,11 +6,11 @@
  * @license MIT License
  */
 import {PriorityQueue} from './priority-queue';
-import type {CompareFunction} from '../../types';
+import type {HeapComparator} from '../../types';
 
-export class MaxPriorityQueue<T = any> extends PriorityQueue<T> {
+export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    compare: CompareFunction<T> = (a: T, b: T) => {
+    compare: HeapComparator<E> = (a: E, b: E) => {
       if (!(typeof a === 'number' && typeof b === 'number')) {
         throw new Error('The a, b params of compare function must be number');
       } else {

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

@@ -6,11 +6,11 @@
  * @license MIT License
  */
 import {PriorityQueue} from './priority-queue';
-import type {CompareFunction} from '../../types';
+import type {HeapComparator} from '../../types';
 
-export class MinPriorityQueue<T = any> extends PriorityQueue<T> {
+export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    compare: CompareFunction<T> = (a: T, b: T) => {
+    compare: HeapComparator<E> = (a: E, b: E) => {
       if (!(typeof a === 'number' && typeof b === 'number')) {
         throw new Error('The a, b params of compare function must be number');
       } else {

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

@@ -7,10 +7,10 @@
  */
 
 import {Heap} from '../heap';
-import {CompareFunction} from '../../types';
+import {HeapComparator} from '../../types';
 
-export class PriorityQueue<T> extends Heap<T> {
-  constructor(comparator: CompareFunction<T>) {
+export class PriorityQueue<E> extends Heap<E> {
+  constructor(comparator: HeapComparator<E>) {
     super(comparator);
   }
 }

package/src/interfaces/binary-tree.ts

@@ -1,7 +1,10 @@
 import {BinaryTreeNode} from '../data-structures';
-import {IAbstractBinaryTree, IAbstractBinaryTreeNode} from './abstract-binary-tree';
+import {BinaryTreeDeletedResult, BinaryTreeNodeKey} from '../types';
 
-export interface IBinaryTreeNode<T, NEIGHBOR extends IBinaryTreeNode<T, NEIGHBOR>>
-  extends IAbstractBinaryTreeNode<T, NEIGHBOR> {}
+export interface IBinaryTree<N extends BinaryTreeNode<N['val'], N>> {
+  createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
 
-export interface IBinaryTree<N extends BinaryTreeNode<N['val'], N>> extends IAbstractBinaryTree<N> {}
+  add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined;
+
+  remove(nodeOrKey: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
+}

package/src/interfaces/{abstract-graph.ts → graph.ts}

@@ -1,6 +1,6 @@
 import {VertexKey} from '../types';
 
-export interface IAbstractGraph<V, E> {
+export interface IGraph<V, E> {
   createVertex(key: VertexKey, val?: V): V;
 
   createEdge(srcOrV1: VertexKey | string, destOrV2: VertexKey | string, weight?: number, val?: E): E;

package/src/interfaces/index.ts

@@ -1,15 +1,8 @@
-export * from './abstract-binary-tree';
-export * from './abstract-graph';
-export * from './avl-tree';
+export * from './graph';
 export * from './binary-tree';
-export * from './bst';
-export * from './directed-graph';
 export * from './doubly-linked-list';
 export * from './heap';
 export * from './navigator';
 export * from './priority-queue';
-export * from './rb-tree';
 export * from './segment-tree';
 export * from './singly-linked-list';
-export * from './tree-multiset';
-export * from './undirected-graph';

package/src/types/data-structures/abstract-graph.ts

@@ -1,5 +1,5 @@
 export type VertexKey = string | number;
-export type EdgeKey = string;
+
 export type DijkstraResult<V> = {
   distMap: Map<V, number>;
   distPaths?: Map<V, V[]>;

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

@@ -1,5 +1,45 @@
 import {BinaryTreeNode} from '../../data-structures/binary-tree';
-import {AbstractBinaryTreeOptions} from './abstract-binary-tree';
+
+/**
+ * Enum representing different loop types.
+ *
+ * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
+ * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
+ */
+
+export enum LoopType {
+  ITERATIVE = 'ITERATIVE',
+  RECURSIVE = 'RECURSIVE'
+}
+
+export enum FamilyPosition {
+  ROOT = 'ROOT',
+  LEFT = 'LEFT',
+  RIGHT = 'RIGHT',
+  ROOT_LEFT = 'ROOT_LEFT',
+  ROOT_RIGHT = 'ROOT_RIGHT',
+  ISOLATED = 'ISOLATED',
+  MAL_NODE = 'MAL_NODE'
+}
+
+export type BinaryTreeNodePropertyName = 'key' | 'val';
+
+export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
+
+export type DFSOrderPattern = 'in' | 'pre' | 'post';
+
+export type BinaryTreeNodeKey = number;
+
+export type BinaryTreeNodeProperty<N extends BinaryTreeNode<N['val'], N>> =
+  | N['val']
+  | N
+  | number
+  | BinaryTreeNodeKey;
+export type BinaryTreeDeletedResult<N> = { deleted: N | null | undefined; needBalanced: N | null };
+
+export type BinaryTreeNodeProperties<N extends BinaryTreeNode<N['val'], N>> =
+  BinaryTreeNodeProperty<N>[];
 
 export type BinaryTreeNodeNested<T> = BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
-export type BinaryTreeOptions = AbstractBinaryTreeOptions & {}
+
+export type BinaryTreeOptions = { loopType?: LoopType }

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

@@ -1,11 +1,11 @@
 import {BSTNode} from '../../data-structures/binary-tree';
-import type {BinaryTreeOptions} from './binary-tree';
-import {BinaryTreeNodeKey} from './abstract-binary-tree';
+import type {BinaryTreeNodeKey, BinaryTreeOptions} from './binary-tree';
 
 export type BSTComparator = (a: BinaryTreeNodeKey, b: BinaryTreeNodeKey) => number;
 
 // prettier-ignore
 export type BSTNodeNested<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
 export type BSTOptions = BinaryTreeOptions & {
   comparator?: BSTComparator,
 }

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

@@ -1 +1,3 @@
-export type CompareFunction<T> = (a: T, b: T) => number;
+export type HeapComparator<T> = (a: T, b: T) => number;
+
+export type HeapDFSOrderPattern = 'pre' | 'in' | 'post';

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

@@ -5,10 +5,8 @@ export * from './segment-tree';
 export * from './tree-multiset';
 export * from './abstract-graph';
 export * from './map-graph';
-export * from './abstract-binary-tree';
 export * from './rb-tree';
 export * from './directed-graph';
-export * from './priority-queue';
 export * from './heap';
 export * from './singly-linked-list';
 export * from './doubly-linked-list';

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

@@ -1,4 +1,5 @@
 export type Direction = 'up' | 'right' | 'down' | 'left';
+
 export type Turning = {[key in Direction]: Direction};
 
 export type NavigatorParams<T = any> = {

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

@@ -1,7 +1,7 @@
-import {CompareFunction, MaxHeap} from '../../../../src';
+import {HeapComparator, MaxHeap} from '../../../../src';
 
 describe('MaxHeap', () => {
-  const numberComparator: CompareFunction<number> = (a, b) => b - a;
+  const numberComparator: HeapComparator<number> = (a, b) => b - a;
   let maxHeap: MaxHeap<number>;
 
   beforeEach(() => {

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

@@ -1,7 +1,7 @@
-import {CompareFunction, MinHeap} from '../../../../src';
+import {HeapComparator, MinHeap} from '../../../../src';
 
 describe('MinHeap', () => {
-  const numberComparator: CompareFunction<number> = (a, b) => a - b;
+  const numberComparator: HeapComparator<number> = (a, b) => a - b;
   let minHeap: MinHeap<number>;
 
   beforeEach(() => {

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

@@ -89,7 +89,8 @@ describe('MaxPriorityQueue Performance Test', () => {
         prev = polled;
       }
     }
-    expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 50);
+    const cost = performance.now() - startTime;
+    expect(cost).toBeLessThan(bigO.LINEAR * 20);
     expect(prev).toBeGreaterThan(0);
   });
 

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

@@ -25,7 +25,7 @@ describe('MinPriorityQueue Operation Test', () => {
     priorityQueue.add(3);
     priorityQueue.add(7);
 
-    expect(priorityQueue.leaf()).toBe(7);
+    expect(priorityQueue.leaf).toBe(7);
   });
 
   it('should check if the queue is empty', () => {