data-structure-typed 1.36.0 → 1.36.1

package/lib/data-structures/binary-tree/bst.d.ts

@@ -9,7 +9,7 @@ import type { BinaryTreeNodeKey, BinaryTreeNodePropertyName, BSTComparator, BSTN
 import { CP } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBST, IBSTNode } from '../../interfaces';
-export declare class BSTNode<V = any, NEIGHBOR extends BSTNode<V, NEIGHBOR> = BSTNodeNested<V>> extends BinaryTreeNode<V, NEIGHBOR> implements IBSTNode<V, NEIGHBOR> {
+export declare class BSTNode<V = any, FAMILY extends BSTNode<V, FAMILY> = BSTNodeNested<V>> extends BinaryTreeNode<V, FAMILY> implements IBSTNode<V, FAMILY> {
     constructor(key: BinaryTreeNodeKey, val?: V);
 }
 export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N> implements IBST<N> {

package/lib/data-structures/binary-tree/rb-tree.d.ts

@@ -1,7 +1,7 @@
 import { BinaryTreeNodeKey, RBColor, RBTreeNodeNested, RBTreeOptions } from '../../types';
 import { IRBTree, IRBTreeNode } from '../../interfaces';
 import { BST, BSTNode } from './bst';
-export declare class RBTreeNode<V = any, NEIGHBOR extends RBTreeNode<V, NEIGHBOR> = RBTreeNodeNested<V>> extends BSTNode<V, NEIGHBOR> implements IRBTreeNode<V, NEIGHBOR> {
+export declare class RBTreeNode<V = any, FAMILY extends RBTreeNode<V, FAMILY> = RBTreeNodeNested<V>> extends BSTNode<V, FAMILY> implements IRBTreeNode<V, FAMILY> {
     private _color;
     constructor(key: BinaryTreeNodeKey, val?: V);
     get color(): RBColor;

package/lib/data-structures/binary-tree/tree-multiset.d.ts

@@ -9,7 +9,7 @@ import type { BinaryTreeNodeKey, TreeMultisetNodeNested, TreeMultisetOptions } f
 import { BinaryTreeDeletedResult, DFSOrderPattern } from '../../types';
 import { ITreeMultiset, ITreeMultisetNode } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
-export declare class TreeMultisetNode<V = any, NEIGHBOR extends TreeMultisetNode<V, NEIGHBOR> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, NEIGHBOR> implements ITreeMultisetNode<V, NEIGHBOR> {
+export declare class TreeMultisetNode<V = any, FAMILY extends TreeMultisetNode<V, FAMILY> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, FAMILY> implements ITreeMultisetNode<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

package/lib/data-structures/heap/heap.d.ts

@@ -1,25 +1,24 @@
 /**
  * data-structure-typed
- *
  * @author Kirk Qi
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
 import type { CompareFunction } from '../../types';
-export declare class Heap<T> {
-    private nodes;
+export declare class Heap<E> {
+    protected nodes: E[];
     private readonly comparator;
-    constructor(comparator: CompareFunction<T>);
+    constructor(comparator: CompareFunction<E>);
     /**
      * 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>;
     /**
      * 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;
     /**
      * Float operation to maintain heap properties after adding an element.
      * @param index - The index of the newly added element.
@@ -38,7 +37,7 @@ export declare 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;
     /**
      * Get the size (number of elements) of the heap.
      */
@@ -47,54 +46,54 @@ export declare 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;
     /**
      * Check if the heap is empty.
      * @returns True if the heap is empty, otherwise false.
      */
     isEmpty(): boolean;
+    /**
+     * Reset the nodes of the heap. Make the nodes empty.
+     */
     clear(): void;
-    refill(nodes: T[]): void;
+    /**
+     * Clear and add nodes of the heap
+     * @param nodes
+     */
+    refill(nodes: E[]): void;
     /**
      * Use a comparison function to check whether a binary heap contains a specific element.
      * @param value - the element to check.
      * @returns Returns true if the specified element is contained; otherwise, returns false.
      */
-    has(value: T): boolean;
-    /**
-     * 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;
+    has(value: E): boolean;
     /**
      * 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[];
+    dfs(order: 'in' | 'pre' | 'post'): E[];
     /**
      * Convert the heap to an array.
      * @returns An array containing the elements of the heap.
      */
-    toArray(): T[];
-    getNodes(): T[];
+    toArray(): E[];
+    getNodes(): E[];
     /**
      * Clone the heap, creating a new heap with the same elements.
      * @returns A new Heap instance containing the same elements.
      */
-    clone(): Heap<T>;
+    clone(): Heap<E>;
     /**
      * Sort the elements in the heap and return them as an array.
      * @returns An array containing the elements sorted in ascending order.
      */
-    sort(): T[];
+    sort(): E[];
     /**
      * Static method that creates a binary heap from an array of nodes and a comparison function.
      * @param nodes
      * @param comparator - Comparison function.
      * @returns A new Heap instance.
      */
-    static heapify<T>(nodes: T[], comparator: CompareFunction<T>): Heap<T>;
+    static heapify<E>(nodes: E[], comparator: CompareFunction<E>): Heap<E>;
 }

package/lib/data-structures/heap/heap.js

@@ -1,6 +1,5 @@
 /**
  * data-structure-typed
- *
  * @author Kirk Qi
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
@@ -103,7 +102,7 @@ export class Heap {
      * 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() {
+    get leaf() {
         var _a;
         return (_a = this.nodes[this.size - 1]) !== null && _a !== void 0 ? _a : null;
     }
@@ -114,9 +113,16 @@ export class Heap {
     isEmpty() {
         return this.size === 0;
     }
+    /**
+     * Reset the nodes of the heap. Make the nodes empty.
+     */
     clear() {
         this.nodes = [];
     }
+    /**
+     * Clear and add nodes of the heap
+     * @param nodes
+     */
     refill(nodes) {
         this.nodes = nodes;
         this.fix();
@@ -129,29 +135,6 @@ export class Heap {
     has(value) {
         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.
-     */
-    findIndex(value, index) {
-        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).

package/lib/data-structures/heap/max-heap.d.ts

@@ -7,6 +7,6 @@
  */
 import { Heap } from './heap';
 import type { CompareFunction } from '../../types';
-export declare class MaxHeap<T = any> extends Heap<T> {
-    constructor(comparator?: CompareFunction<T>);
+export declare class MaxHeap<E = any> extends Heap<E> {
+    constructor(comparator?: CompareFunction<E>);
 }

package/lib/data-structures/heap/min-heap.d.ts

@@ -7,6 +7,6 @@
  */
 import { Heap } from './heap';
 import type { CompareFunction } from '../../types';
-export declare class MinHeap<T = any> extends Heap<T> {
-    constructor(comparator?: CompareFunction<T>);
+export declare class MinHeap<E = any> extends Heap<E> {
+    constructor(comparator?: CompareFunction<E>);
 }

package/lib/data-structures/priority-queue/max-priority-queue.d.ts

@@ -7,6 +7,6 @@
  */
 import { PriorityQueue } from './priority-queue';
 import type { CompareFunction } from '../../types';
-export declare class MaxPriorityQueue<T = any> extends PriorityQueue<T> {
-    constructor(compare?: CompareFunction<T>);
+export declare class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
+    constructor(compare?: CompareFunction<E>);
 }

package/lib/data-structures/priority-queue/min-priority-queue.d.ts

@@ -7,6 +7,6 @@
  */
 import { PriorityQueue } from './priority-queue';
 import type { CompareFunction } from '../../types';
-export declare class MinPriorityQueue<T = any> extends PriorityQueue<T> {
-    constructor(compare?: CompareFunction<T>);
+export declare class MinPriorityQueue<E = any> extends PriorityQueue<E> {
+    constructor(compare?: CompareFunction<E>);
 }

package/lib/data-structures/priority-queue/priority-queue.d.ts

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

package/lib/types/data-structures/abstract-binary-tree.d.ts

@@ -29,6 +29,4 @@ export type BinaryTreeDeletedResult<N> = {
 export type AbstractBinaryTreeNodeProperty<N extends AbstractBinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeKey;
 export type AbstractBinaryTreeNodeProperties<N extends AbstractBinaryTreeNode<N['val'], N>> = AbstractBinaryTreeNodeProperty<N>[];
 export type AbstractBinaryTreeNodeNested<T> = AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type AbstractBinaryTreeOptions = {
-    loopType?: LoopType;
-};
+export type AbstractBinaryTreeOptions = {};

package/lib/types/data-structures/binary-tree.d.ts

@@ -1,4 +1,6 @@
 import { BinaryTreeNode } from '../../data-structures/binary-tree';
-import { AbstractBinaryTreeOptions } from './abstract-binary-tree';
+import { AbstractBinaryTreeOptions, LoopType } from './abstract-binary-tree';
 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 = AbstractBinaryTreeOptions & {
+    loopType?: LoopType;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.36.0",
+  "version": "1.36.1",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/index.js",
   "module": "lib/index.js",
@@ -54,10 +54,10 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.35.1",
+    "avl-tree-typed": "^1.36.0",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.35.1",
-    "bst-typed": "^1.35.1",
+    "binary-tree-typed": "^1.36.0",
+    "bst-typed": "^1.36.0",
     "dependency-cruiser": "^14.1.0",
     "eslint": "^8.50.0",
     "eslint-config-prettier": "^9.0.0",