declare class Node$4<T> {
    value: T;
    next: Node$4<T> | null;
    constructor(value: T);
}
interface ILinkedList<T> {
    push(value: T): Node$4<T>;
    pop(): void;
    shift(): void;
    unshift(value: T): Node$4<T>;
    get(index: number): Node$4<T> | null;
    set(index: number, value: T): Node$4<T> | null;
    insert(index: number, value: T): Node$4<T> | null;
    remove(index: number): void;
    reverse(): unknown;
    traverse(): void;
}
declare class LinkedList<T> implements ILinkedList<T> {
    private head;
    private tail;
    private length;
    push(value: T): Node$4<T>;
    pop(): void;
    shift(): void;
    unshift(value: T): Node$4<T>;
    get(index: number): Node$4<T> | null;
    set(index: number, value: T): Node$4<T> | null;
    insert(index: number, value: T): Node$4<T> | null;
    remove(index: number): void;
    reverse(): unknown;
    traverse(): void;
}

declare class Node$3<T> {
    value: T;
    next: Node$3<T> | null;
    prev: Node$3<T> | null;
    constructor(value: T);
}
interface IDoublyLinkedList<T> {
    push(value: T): Node$3<T>;
    pop(): void;
    shift(): void;
    unshift(value: T): Node$3<T>;
    get(index: number): Node$3<T> | null;
    set(index: number, value: T): Node$3<T> | null;
    insert(index: number, value: T): Node$3<T> | null;
    remove(index: number): void;
    traverse(): unknown;
}
declare class DoublyLinkedList<T> implements IDoublyLinkedList<T> {
    private head;
    private tail;
    private length;
    push(value: T): Node$3<T>;
    pop(): void;
    shift(): void;
    unshift(value: T): Node$3<T>;
    get(index: number): Node$3<T> | null;
    set(index: number, value: T): Node$3<T> | null;
    insert(index: number, value: T): Node$3<T> | null;
    remove(index: number): void;
    traverse(): void;
}

declare class Node$2<T> {
    value: T;
    next: Node$2<T> | null;
    constructor(value: T);
}
interface IQueue<T> {
    enqueue(value: T): Node$2<T>;
    dequeue(): void;
    peek(): T | null;
    isEmpty(): boolean;
    getSize(): number;
}
declare class Queue<T> implements IQueue<T> {
    private front;
    private rear;
    private size;
    enqueue(value: T): Node$2<T>;
    dequeue(): void;
    peek(): T | null;
    isEmpty(): boolean;
    getSize(): number;
}

declare class Node$1<T> {
    value: T;
    next: Node$1<T> | null;
    constructor(value: T);
}
interface IStack<T> {
    push(value: T): Node$1<T>;
    pop(): void;
    top(): T | null;
    isEmpty(): boolean;
    getSize(): number;
}
declare class Stack<T> implements IStack<T> {
    private first;
    private last;
    private size;
    push(value: T): Node$1<T>;
    pop(): void;
    top(): T | null;
    isEmpty(): boolean;
    getSize(): number;
}

declare class BSTNode<T> {
    value: T;
    left: BSTNode<T> | null;
    right: BSTNode<T> | null;
    constructor(value: T);
}
interface IBinarySearchTree<T> {
    insert(value: T): BSTNode<T> | null;
    isPresent(value: T): boolean;
    getRoot(): BSTNode<T> | null;
}
declare class BinarySearchTree<T> implements IBinarySearchTree<T> {
    private root;
    insert(value: T): BSTNode<T> | null;
    isPresent(value: T): boolean;
    getRoot(): BSTNode<T> | null;
}

interface IMinHeap {
    insert(value: number): void;
    extractMin(): number | undefined;
    peek(): number | undefined;
    size(): number;
    isEmpty(): boolean;
}
declare class MinHeap implements IMinHeap {
    private heap;
    insert(value: number): void;
    extractMin(): number | undefined;
    peek(): number | undefined;
    size(): number;
    isEmpty(): boolean;
    private bubbleUp;
    private bubbleDown;
    private swap;
}

declare class HashMap<K, V> {
    private buckets;
    private bucketCount;
    private _size;
    constructor(capacity?: number);
    getSize(): number;
    set(key: K, value: V): void;
    get(key: K): V | undefined;
    has(key: K): boolean;
    delete(key: K): boolean;
    keys(): K[];
    values(): V[];
    private hash;
}

interface GraphEdge<T> {
    node: T;
    weight: number;
}
declare class Graph<T extends string | number = string> {
    private adjacency;
    private directed;
    constructor(directed?: boolean);
    addVertex(vertex: T): void;
    addEdge(from: T, to: T, weight?: number): void;
    getNeighbors(vertex: T): GraphEdge<T>[];
    getVertices(): T[];
    isDirected(): boolean;
}

declare const linearSearch: (arr: number[], number: number) => number;

declare const binarySearch: (arr: number[], num: number) => number;

declare const jumpSearch: (arr: number[], target: number) => number;

declare const exponentialSearch: (arr: number[], target: number) => number;

declare const bubbleSort: (arr: number[]) => number[];

declare const insertionSort: (nums: number[]) => number[];

declare const selectionSort: (nums: number[]) => number[];

declare const mergeSort: (arr: number[]) => number[];

declare const quickSort: (arr: number[], left?: number, right?: number) => number[];

declare const heapSort: (arr: number[]) => number[];

declare const countingSort: (arr: number[]) => number[];

declare const radixSort: (arr: number[]) => number[];

declare class Node<T> {
    value: T;
    left: Node<T> | null;
    right: Node<T> | null;
    constructor(value: T);
}

declare function bfs<T>(root: Node<T> | null): T[] | null;

declare function preOrder<T>(root: Node<T> | null): T[] | null;

declare function inOrder<T>(root: Node<T> | null): T[] | null;

declare function postOrder<T>(root: Node<T> | null): T[] | null;

declare function graphBfs<T extends string | number>(graph: Graph<T>, start: T): T[];

declare function graphDfs<T extends string | number>(graph: Graph<T>, start: T): T[];

interface DijkstraResult<T extends string | number> {
    distances: Map<T, number>;
    previous: Map<T, T | null>;
    path?: T[];
}
declare function dijkstra<T extends string | number>(graph: Graph<T>, start: T, end?: T): DijkstraResult<T>;

declare function topologicalSort<T extends string | number>(graph: Graph<T>): T[];

export { BSTNode, BinarySearchTree, DijkstraResult, DoublyLinkedList, Graph, GraphEdge, HashMap, LinkedList, MinHeap, Node, Queue, Stack, bfs, binarySearch, bubbleSort, countingSort, dijkstra, exponentialSearch, graphBfs, graphDfs, heapSort, inOrder, insertionSort, jumpSearch, linearSearch, mergeSort, postOrder, preOrder, quickSort, radixSort, selectionSort, topologicalSort };