import { Comparator } from '../../../java/util/Comparator';
import { JavaIterator } from '../../../java/util/JavaIterator';
import { Collection } from '../../../java/util/Collection';
import { Cloneable } from '../../../java/lang/Cloneable';
import { JavaObject } from '../../../java/lang/JavaObject';
import { Queue } from '../../../java/util/Queue';
export declare class MinHeap<T> extends JavaObject implements Queue<T>, Cloneable {
    private _size;
    private _nodes;
    private readonly _comparator;
    private readonly _initialCapacity;
    protected _modCount: number;
    /**
     * Erzeugt einen neuen Minimum-Heap mit dem übergebenen {@link Comparator} und
     * der übergebenen initialen Kapazität.
     *
     * @param comparator      das Objekt zum Vergleich von zwei Objekten des Typ T
     * @param initialCapacity die initiale Kapazität des Baums
     */
    constructor(comparator: Comparator<T>, initialCapacity: number);
    /**
     * Erzeugt einen neuen Minimum-Heap mit dem übergebenen {@link Comparator} und
     * einer initialen Kapazität von 63.
     *
     * @param comparator das Objekt zum Vergleich von zwei Objekten des Typ T
     */
    constructor(comparator: Comparator<T>);
    /**
     * Erstellt eine Kopie des als Parameter übergebenen Heaps.
     *
     * @param original    Das zu kopierende Original
     */
    constructor(original: MinHeap<T>);
    add(e: T): boolean;
    element(): T;
    offer(e: T): boolean;
    peek(): T | null;
    poll(): T | null;
    remove(): T;
    remove(o: unknown | null): boolean;
    size(): number;
    isEmpty(): boolean;
    contains(o: unknown | null): boolean;
    containsAll(c: Collection<unknown> | null): boolean;
    addAll(c: Collection<T> | null): boolean;
    removeAll(c: Collection<unknown> | null): boolean;
    retainAll(c: Collection<unknown> | null): boolean;
    clear(): void;
    toArray(): Array<unknown>;
    toArray<U>(a: Array<U>): Array<U>;
    iterator(): JavaIterator<T>;
    clone(): unknown;
    /**
     * Gibt den {@link Comparator} des Minimum Heaps zurück.
     *
     * @return der Comparator
     */
    comparator(): Comparator<T>;
    /**
     * Gibt die aktuelle Kapazität des Arrays zurück.
     *
     * @return die aktuelle Kapazität des Arrays zurück
     */
    capacity(): number;
    /**
     * Gibt den Inhalt des Minimum Heaps in einem sortierten Array zurück.
     *
     * @return ein sortiertes Array mit den Elementen des Minimum Heaps.
     */
    toSortedArray(): Array<T>;
    /**
     * Gibt den Inhalt des Heaps als Array-Repräsentation aus.
     *
     * @return der Inhalt des Heaps
     */
    toString(): String;
    /**
     * Ermittelt eine Hash-Code für dieses Objekt basierend auf den gespeicherten
     * Daten im Heap (die konkrete Ordnung des Baumes wird nicht unterschieden).
     *
     * @return der Hashcode des Minimum Heaps
     */
    hashCode(): number;
    /**
     * Prüft, ob das übergebene Objekt ein Minimum-Heap ist, der
     * die gleichen Elemente mit der gleichen Ordnung beinhaltet.
     *
     * @param obj   das zu vergleichende Objekt
     */
    equals(obj: unknown | null): boolean;
    /**
     * Liefert zum Index i den Index des Elter zurück.
     *
     * @param i
     *
     * @return den Index des Elter
     */
    private static getParentIndex;
    /**
     * Liefert zum Index i den Index des linken Kindes zurück.
     *
     * @param i
     *
     * @return den Index des linken Kindes
     */
    private static getLeftChildIndex;
    /**
     * Liefert zum Index i den Index des rechten Kindes zurück.
     *
     * @param i
     *
     * @return den Index des rechten Kindes
     */
    private static getRightChildIndex;
    /**
     * Tauscht die Elemente an den Stellen i und j im Array
     *
     * @param i
     * @param j
     */
    private swap;
    /**
     * Stellt die Minimum Heap Eigenschaft vom Index i aus im Baum abwärts her.
     *
     * @param i   ab diesem Index wird im Baum abwärts geprüft.
     */
    private heapifyDown;
    /**
     * Stellt die Minimum-Heap-Eigenschaft des Arrays ab Position i aufwärts wieder her.
     *
     * @param i   ab diesem Index wird überprüft
     */
    private heapifyUp;
    /**
     * Erstellt ein neues Array vom Typ T mit der angegebenen Länge.
     *
     * @param elem     Ein Element vom Typ T, welches als Vorlage für die Elemente des Arrays dient
     * @param length   die Länge des neuen Arrays
     *
     * @return das neue Array
     */
    private newArray;
    /**
     * Erzeugt eine Kopie des internen Arrays _nodes.
     *
     * @return die Kopie des _nodes-Array.
     */
    private copyNodes;
    /**
     * Lässt den dem Baum zu Grunde liegenden Baum wachsen. Verdoppelt die Menge der Elemente, die im Heap
     * gespeichert werden können.
     *
     * Falls der Heap durch das Wachsen auf mehr als {@link Integer.MAX_VALUE} Elemente ansteigen würde,
     * wird eine IllegalStateException geworfen.
     *
     * @throws IllegalStateException
     */
    private grow;
    /**
     * Findet den Index an dem das Element t im dem dem Heap zu Grunde liegendem Array gespeichert ist.
     * Gibt -1 zurück, falls das Element nicht vorhanden ist.
     *
     * @param t   zu diesem Element soll der Index gefunden werden
     *
     * @return  der Index, falls das Element enthalten ist, ansonsten -1
     */
    private findIndex;
    /**
     * Gibt die Anzahl der Operationen zurück, die diese Datenstruktur
     * verändert haben.
     *
     * @return die Anzahl der Operationen
     */
    getModCount(): number;
    isTranspiledInstanceOf(name: string): boolean;
    [Symbol.iterator](): Iterator<T>;
}
export declare function cast_de_nrw_schule_svws_core_adt_tree_MinHeap<T>(obj: unknown): MinHeap<T>;