`` `Java
classe pubblica ArrayHeap {
privato int [] heap;
dimensione privata int;
Capacità privata int;
Public ArrayHeap (int capacità) {
this.capacity =capacità;
this.heap =new int [capacità + 1]; // L'indice 0 non viene utilizzato
this.size =0;
}
// funzione di supporto per ottenere l'indice principale
privato int genitore (int i) {
restituire i / 2;
}
// funzione di supporto per ottenere l'indice del bambino sinistro
privato int sinistra (int i) {
restituire 2 * i;
}
// funzione di supporto per ottenere l'indice del bambino giusto
privato int diritto (int i) {
restituire 2 * i + 1;
}
// Funzione di supporto per accumulare dopo l'inserimento
Private void heaPifyUp (int i) {
while (i> 1 &&heap [genitore (i)]> heap [i]) {
swap (i, genitore (i));
i =genitore (i);
}
}
// Funzione di supporto per accumulare dopo la cancellazione
Private void heaPifyDown (int i) {
int più piccolo =i;
int l =sinistra (i);
int r =destra (i);
if (l <=size &&heap [l]
}
if (r <=size &&heap [r]
}
if (più piccolo! =i) {
Swap (i, più piccolo);
heapifydown (più piccolo);
}
}
// funzione di supporto per scambiare due elementi
swap vuoto privato (int i, int j) {
int temp =heap [i];
heap [i] =heap [j];
heap [j] =temp;
}
// Inserisci un nuovo elemento nel mucchio
public void insert (int key) {
if (size ==capacità) {
lanciare nuovi illegalstateException ("heap è pieno");
}
dimensione ++;
heap [size] =tasto;
heapifyup (dimensione);
}
// estratto (e rimuovi) l'elemento minimo
public int extractmin () {
if (size ==0) {
lanciare un nuovo illegalstateException ("heap è vuoto");
}
int min =heap [1];
heap [1] =heap [dimensione];
misurare--;
HeaPifyDown (1);
ritorno min;
}
// ottieni l'elemento minimo senza rimuoverlo
public int peekmin () {
if (size ==0) {
lanciare un nuovo illegalstateException ("heap è vuoto");
}
restituire heap [1];
}
// Controlla se l'heap è vuoto
public boolean isempty () {
Restituisci dimensioni ==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 ("Elemento minimo:" + heap.peekmin ()); // output:3
System.out.println ("Elemento minimo estratto:" + heap.extractmin ()); // output:3
System.out.println ("Nuovo elemento minimo:" + heap.peekmin ()); // output:5
}
}
`` `
Questa implementazione fornisce operazioni di heap di base. Ricorda che questo è un *min-heap *; Per renderlo un *max-heap *, dovresti invertire la logica di confronto in `heapifyup` e` heapifydown`. Per cumuli più grandi, prendere in considerazione l'utilizzo di una struttura di dati o una libreria più sofisticata se le prestazioni diventano critiche. Puoi anche estenderlo per gestire i generici per tipi di dati più versatili. Ricorda di gestire potenziali eccezioni come `IllegalstateException` per cumuli vuoti o pieni.
Informazioni correlate
Programmazione © www.354353.com