Ecco un'implementazione di Java di un Min-Heap, compresi i metodi per l'inserimento, l'estrazione dell'elemento minimo e l'Accancio delle operazioni:
`` `Java
Classe pubblica MinHeap {
privato int [] heap;
dimensione privata int;
Capacità privata int;
public MinHeap (int capacità) {
this.capacity =capacità;
this.heap =new int [capacità + 1]; // L'indice 0 non viene utilizzato
this.size =0;
}
public boolean isempty () {
Restituisci dimensioni ==0;
}
public boolean isfull () {
dimensione di ritorno ==capacità;
}
privato int genitore (int i) {
restituire i / 2;
}
privato int sinistra (int i) {
restituire 2 * i;
}
privato int diritto (int i) {
restituire 2 * i + 1;
}
swap vuoto privato (int i, int j) {
int temp =heap [i];
heap [i] =heap [j];
heap [j] =temp;
}
public void insert (int key) {
if (isfull ()) {
lanciare nuovi illegalstateException ("heap è pieno");
}
dimensione ++;
heap [size] =tasto;
int i =dimensione;
while (i> 1 &&heap [genitore (i)]> heap [i]) {// proprietà min-heap
swap (i, genitore (i));
i =genitore (i);
}
}
public int extractmin () {
if (isEmpty ()) {
lanciare un nuovo illegalstateException ("heap è vuoto");
}
int root =heap [1];
heap [1] =heap [dimensione];
misurare--;
heapify (1);
Restituzione radice;
}
Private void heaPify (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);
accumulare (più piccolo);
}
}
public void Printheap () {
per (int i =1; i <=size; i ++) {
System.out.print (heap [i] + "");
}
System.out.println ();
}
public static void main (string [] args) {
MinHeap MinHeap =new MinHeap (10);
MinHeap.insert (3);
MinHeap.insert (2);
MinHeap.insert (15);
MinHeap.insert (5);
MinHeap.insert (4);
MinHeap.insert (45);
System.out.println ("Array MinHeap:");
MinHeap.printHeap ();
System.out.println ("estratto min:" + minHeap.extractmin ());
System.out.println ("Dopo aver estratto min:");
MinHeap.printHeap ();
}
}
`` `
Questo codice include:
* costruttore: Inizializza l'array heap con una determinata capacità. Si noti che l'indice 0 non viene utilizzato.
* `isEmpty ()` e `isfull ()`: Controlla lo stato del mucchio.
* `parent ()`, `left ()`, `destro ()`: L'aiuto funziona per ottenere gli indici dei nodi genitorie e figlio.
* `swap ()`: Scambia due elementi nell'array.
* `insert ()`: Inserisce un nuovo elemento nel mucchio, mantenendo la proprietà Min-heap.
* `extractmin ()`: Rimuove e restituisce l'elemento minimo (radice), mantenendo la proprietà min-heap usando `heapify ()`.
* `Heapify ()`: Ripristina la proprietà Min-Heap dopo che un elemento viene rimosso o inserito. Confronta ricorsivamente un elemento con i suoi figli e se necessario.
* `Printheap ()`: Una funzione di supporto per la dimostrazione.
Ricorda di gestire potenziali eccezioni, come cercare di estrarre da un mucchio vuoto o inserire in uno pieno. Questo esempio utilizza i valori interi; Puoi adattarlo facilmente ad altri tipi di dati utilizzando un parametro di tipo generico. Per cumuli più grandi, prendere in considerazione l'uso di una strategia di ridimensionamento più sofisticata per evitare la limitazione della capacità fissa.
Informazioni correlate
Programmazione © www.354353.com