Durch die Implementierung eines Array-basierten Heaps (Mine-heap in diesem Beispiel) in Java werden ein einzelnes Array verwendet, um die Haufenstruktur darzustellen. So können Sie es tun, einschließlich Methoden zum Einfügen, Löschen (Extraktion des Mindestelements) und Peek (Peek (Mindestelement erhalten, ohne es zu entfernen):
`` `Java
öffentliche Klasse Arrayheap {
privat int [] haufen;
private intgröße;
private intkapazität;
öffentliche Arrayheap (int -Kapazität) {
this.capacity =Kapazität;
this.heap =new int [Kapazität + 1]; // Index 0 wird nicht verwendet
this.size =0;
}
// Helferfunktion, um den übergeordneten Index zu erhalten
private int Eltern (int i) {
Return I / 2;
}
// Helferfunktion, um den linken untergeordneten Index zu erhalten
private int links (int i) {
zurück 2 * i;
}
// Helferfunktion, um den richtigen Kinderindex zu erhalten
private int right (int i) {
Rückkehr 2 * i + 1;
}
// Helferfunktion, um nach dem Einfügen aufzuhäufen
private void heapifyUp (int i) {
while (i> 1 &&heap [parent (i)]> heap [i]) {
Swap (i, Elternteil (i));
i =Eltern (i);
}
}
// Helferfunktion, um nach dem Löschen nach unten zu häufen
private void heapifydown (int i) {
int kleinste =i;
int l =links (i);
int r =rechts (i);
if (l <=size &&heap [l]
kleinste =l;
}
if (r <=size &&heap [r]
kleinste =r;
}
if (kleinste! =i) {
tauschen (ich, kleinste);
heapifydown (kleinste);
}
}
// Helferfunktion, um zwei Elemente auszutauschen
privater void -Swap (int i, int j) {
int temp =heap [i];
heap [i] =heap [j];
Heap [j] =temp;
}
// Fügen Sie ein neues Element in den Haufen ein
public void Insert (int key) {
if (size ==Kapazität) {
Neue IllegalStateException werfen ("Heap ist voll");
}
Größe ++;
Haufen [Größe] =Schlüssel;
heapifyUp (Größe);
}
// das minimale Element extrahieren (und entfernen)
public int extractmin () {
if (size ==0) {
Neue IllegalStateException werfen ("Heap ist leer");
}
int min =haufen [1];
Heap [1] =Heap [Größe];
Größe--;
heapifydown (1);
Rückkehr min;
}
// Erhalten Sie das Mindestelement, ohne es zu entfernen
public int peekmin () {
if (size ==0) {
Neue IllegalStateException werfen ("Heap ist leer");
}
Return Heap [1];
}
// Überprüfen Sie, ob der Haufen leer ist
public boolean isempty () {
Return Size ==0;
}
public static void main (String [] args) {
Arrayheap Heap =New Arrayheap (10);
heap.insert (10);
heap.insert (5);
Heap.insert (15);
heap.insert (3);
Heap.insert (8);
System.out.println ("Mindestelement:" + heap.peekmin ()); // Ausgabe:3
System.out.println ("extrahiertes minimales Element:" + heap.extractmin ()); // Ausgabe:3
System.out.println ("neues Mindestelement:" + heap.peekmin ()); // Ausgabe:5
}
}
`` `
Diese Implementierung liefert grundlegende Heap -Operationen. Denken Sie daran, dass dies ein *min-heap *ist; Um es zu einem *max-heap *zu machen, müssten Sie die Vergleichslogik in "heapifyUp" und "heapifydown" umkehren. Für größere Haufen sollten Sie eine ausgefeiltere Datenstruktur oder Bibliothek verwenden, wenn die Leistung kritisch wird. Sie können dies auch so erweitern, dass Generika für vielseitigere Datentypen verarbeitet werden. Denken Sie daran, potenzielle Ausnahmen wie "illegalStateException" für leere oder volle Haufen zu behandeln.
