heap sort c with examples
Un'introduzione all'ordinamento di heap con esempi.
Heapsort è una delle tecniche di smistamento più efficienti. Questa tecnica crea un heap dall'array non ordinato specificato e quindi utilizza di nuovo l'heap per ordinare l'array.
Heapsort è una tecnica di ordinamento basata sul confronto e utilizza l'heap binario.
=> Leggi la serie di formazione Easy C ++.
qual è il miglior downloader di musica gratuito per Android
Cosa imparerai:
- Che cos'è un mucchio binario?
- Algoritmo generale
- Illustrazione
- Esempio C ++
- Esempio Java
- Conclusione
- Lettura consigliata
Che cos'è un mucchio binario?
Un heap binario viene rappresentato utilizzando un albero binario completo. Un albero binario completo è un albero binario in cui tutti i nodi di ogni livello sono completamente riempiti tranne i nodi foglia ei nodi sono fino a sinistra.
Un heap binario o semplicemente un heap è un albero binario completo in cui gli elementi oi nodi vengono archiviati in modo tale che il nodo radice sia maggiore dei suoi due nodi figlio. Questo è anche chiamato max heap.
Gli elementi nell'heap binario possono anche essere archiviati come min-heap in cui il nodo radice è più piccolo dei suoi due nodi figlio. Possiamo rappresentare un mucchio come un albero binario o un array.
Pur rappresentando un heap come un array, supponendo che l'indice inizi da 0, l'elemento radice viene memorizzato a 0. In generale, se un nodo padre si trova nella posizione I, il nodo figlio sinistro si trova nella posizione (2 * I + 1) e il nodo destro è in (2 * I +2).
Algoritmo generale
Di seguito è riportato l'algoritmo generale per la tecnica di ordinamento degli heap.
- Crea un heap massimo dai dati forniti in modo che la radice sia l'elemento più alto dell'heap.
- Rimuovere la radice, ovvero l'elemento più alto dall'heap, e sostituirlo o scambiarlo con l'ultimo elemento dell'heap.
- Quindi regola il max heap, in modo da non violare le proprietà max heap (heapify).
- Il passaggio precedente riduce la dimensione dell'heap di 1.
- Ripetere i tre passaggi precedenti fino a quando la dimensione dell'heap non viene ridotta a 1.
Come mostrato nell'algoritmo generale per ordinare il dataset dato in ordine crescente, per prima cosa costruiamo un heap massimo per i dati dati.
Facciamo un esempio per costruire un heap max con il seguente set di dati.
6, 10, 2, 4, 1
Possiamo costruire un albero per questo set di dati come segue.
Nella rappresentazione ad albero sopra, i numeri tra parentesi rappresentano le rispettive posizioni nella matrice.
Per costruire un heap massimo della rappresentazione di cui sopra, dobbiamo soddisfare la condizione di heap che il nodo genitore dovrebbe essere maggiore dei suoi nodi figli. In altre parole, abbiamo bisogno di 'heapify' l'albero in modo da convertirlo in max-heap.
Dopo l'heapification dell'albero sopra, otterremo il max-heap come mostrato di seguito.
Come mostrato sopra, abbiamo questo max-heap generato da un array.
Successivamente, presentiamo un'illustrazione di un ordinamento di heap. Dopo aver visto la costruzione di max-heap, salteremo i passaggi dettagliati per costruire un max-heap e mostreremo direttamente l'heap massimo ad ogni passaggio.
Illustrazione
Considera la seguente serie di elementi. Dobbiamo ordinare questo array usando la tecnica di ordinamento dell'heap.
Costruiamo un max-heap come mostrato di seguito per ordinare l'array.
Una volta che l'heap è stato costruito, lo rappresentiamo in una forma Array come mostrato di seguito.
Ora confrontiamo l'1stnode (root) con l'ultimo nodo e poi scambiarli. Quindi, come mostrato sopra, scambiamo 17 e 3 in modo che 17 sia nell'ultima posizione e 3 sia nella prima posizione.
Ora rimuoviamo il nodo 17 dall'heap e lo inseriamo nell'array ordinato come mostrato nella parte ombreggiata di seguito.
Ora costruiamo di nuovo un heap per gli elementi dell'array. Questa volta la dimensione dell'heap è ridotta di 1 poiché abbiamo eliminato un elemento (17) dall'heap.
miglior sito per guardare anime gratis
L'heap degli elementi rimanenti è mostrato di seguito.
Nel passaggio successivo, ripeteremo gli stessi passaggi.
Confrontiamo e scambiamo l'elemento radice e l'ultimo elemento nell'heap.
Dopo lo scambio, eliminiamo l'elemento 12 dall'heap e lo spostiamo nell'array ordinato.
Ancora una volta costruiamo un heap massimo per gli elementi rimanenti come mostrato di seguito.
Ora scambiamo la radice e l'ultimo elemento, cioè 9 e 3. Dopo lo scambio, l'elemento 9 viene cancellato dall'heap e inserito in un array ordinato.
A questo punto, abbiamo solo tre elementi nell'heap come mostrato di seguito.
Scambiamo 6 e 3 ed eliminiamo l'elemento 6 dall'heap e lo aggiungiamo all'array ordinato.
Ora costruiamo un mucchio degli elementi rimanenti e poi scambiamo entrambi l'uno con l'altro.
Dopo aver scambiato 4 e 3, eliminiamo l'elemento 4 dall'heap e lo aggiungiamo all'array ordinato. Ora abbiamo un solo nodo rimasto nell'heap come mostrato di seguito .
Quindi ora con un solo nodo rimanente, lo eliminiamo dall'heap e lo aggiungiamo all'array ordinato.
Quindi quanto sopra mostrato è l'array ordinato che abbiamo ottenuto come risultato dell'ordinamento dell'heap.
Nell'illustrazione sopra, abbiamo ordinato l'array in ordine crescente. Se dobbiamo ordinare l'array in ordine decrescente, dobbiamo seguire gli stessi passaggi ma con il min-heap.
L'algoritmo di Heapsort è identico all'ordinamento di selezione in cui selezioniamo l'elemento più piccolo e lo posizioniamo in un array ordinato. Tuttavia, l'ordinamento dell'heap è più veloce dell'ordinamento della selezione per quanto riguarda le prestazioni. Possiamo metterlo come heapsort è una versione migliorata dell'ordinamento di selezione.
dfs utilizzando lo stack c ++
Successivamente, implementeremo Heapsort in C ++ e linguaggio Java.
La funzione più importante in entrambe le implementazioni è la funzione 'heapify'. Questa funzione viene chiamata dalla routine heapsort principale per riorganizzare la sottostruttura una volta che un nodo viene eliminato o quando viene creato max-heap.
Quando avremo accumulato correttamente l'albero, solo allora saremo in grado di ottenere gli elementi corretti nelle loro posizioni corrette e quindi l'array sarà ordinato correttamente.
Esempio C ++
Di seguito è riportato il codice C ++ per l'implementazione di heapsort.
#include using namespace std; // function to heapify the tree void heapify(int arr(), int n, int root) { int largest = root; // root is the largest element int l = 2*root + 1; // left = 2*root + 1 int r = 2*root + 2; // right = 2*root + 2 // If left child is larger than root if (l arr(largest)) largest = l; // If right child is larger than largest so far if (r arr(largest)) largest = r; // If largest is not root if (largest != root) { //swap root and largest swap(arr(root), arr(largest)); // Recursively heapify the sub-tree heapify(arr, n, largest); } } // implementing heap sort void heapSort(int arr(), int n) { // build heap for (int i = n / 2 - 1; i >= 0; i--) heapify(arr, n, i); // extracting elements from heap one by one for (int i=n-1; i>=0; i--) { // Move current root to end swap(arr(0), arr(i)); // again call max heapify on the reduced heap heapify(arr, i, 0); } } /* print contents of array - utility function */ void displayArray(int arr(), int n) { for (int i=0; i Produzione:
Matrice di input
4 17 3 12 9 6
Matrice ordinata
3 4 6 9 12 17
Successivamente, implementeremo l'heaport in linguaggio Java
Esempio Java
// Java program to implement Heap Sort class HeapSort { public void heap_sort(int arr()) { int n = arr.length; // Build heap (rearrange array) for (int i = n / 2 - 1; i >= 0; i--) heapify(arr, n, i); // One by one extract an element from heap for (int i=n-1; i>=0; i--) { // Move current root to end int temp = arr(0); arr(0) = arr(i); arr(i) = temp; // call max heapify on the reduced heap heapify(arr, i, 0); } } // heapify the sub-tree void heapify(int arr(), int n, int root) { int largest = root; // Initialize largest as root int l = 2*root + 1; // left = 2*root + 1 int r = 2*root + 2; // right = 2*root + 2 // If left child is larger than root if (l arr(largest)) largest = l; // If right child is larger than largest so far if (r arr(largest)) largest = r; // If largest is not root if (largest != root) { int swap = arr(root); arr(root) = arr(largest); arr(largest) = swap; // Recursively heapify the affected sub-tree heapify(arr, n, largest); } } //print array contents - utility function static void displayArray(int arr()) { int n = arr.length; for (int i=0; i Produzione:
Matrice di input:
4 17 3 12 9 6
Matrice ordinata:
3 4 6 9 12 17
Conclusione
Heapsort è una tecnica di ordinamento basata sul confronto che utilizza l'heap binario.
Può essere definito come un miglioramento rispetto all'ordinamento di selezione poiché entrambe queste tecniche di ordinamento funzionano con una logica simile per trovare ripetutamente l'elemento più grande o più piccolo nella matrice e quindi posizionarla nella matrice ordinata.
L'ordinamento dell'heap utilizza max-heap o min-heap per ordinare l'array. Il primo passaggio nell'ordinamento dell'heap consiste nel creare un heap minimo o massimo dai dati dell'array, quindi eliminare l'elemento radice in modo ricorsivo e heapify l'heap finché non è presente un solo nodo nell'heap.
Heapsort è un algoritmo efficiente ed è più veloce dell'ordinamento di selezione. Può essere usato per ordinare un array quasi ordinato o per trovare k elementi più grandi o più piccoli nell'array.
Con questo, abbiamo completato il nostro argomento sulle tecniche di ordinamento in C ++. Dal nostro prossimo tutorial in poi, inizieremo con le strutture dati una per una.
=> Cerca qui l'intera serie di formazione C ++.
Lettura consigliata
- Metodo MongoDB Sort () con esempi
- Comando di ordinamento Unix con sintassi, opzioni ed esempi
- Unisci ordinamento in C ++ con esempi
- Ordinamento della shell in C ++ con esempi
- Ordinamento di inserzione in C ++ con esempi
- Ordinamento di selezione in C ++ con esempi
- Bubble Sort in C ++ con esempi
- Ordinamento rapido in C ++ con esempi