heap sort c with examples
O introducere pentru sortarea în grămadă cu exemple.
Heapsort este una dintre cele mai eficiente tehnici de sortare. Această tehnică construiește o grămadă din matricea nesortată dată și apoi folosește grămada din nou pentru a sorta matricea.
Heapsort este o tehnică de sortare bazată pe comparație și utilizează heap binar.
=> Citiți seria Easy C ++ Training.
cel mai bun site pentru a viziona anime online
Ce veți învăța:
- Ce este o grămadă binară?
- Algoritm general
- Ilustrare
- Exemplu C ++
- Exemplu Java
- Concluzie
- Lectură recomandată
Ce este o grămadă binară?
O grămadă binară este reprezentată folosind un arbore binar complet. Un copac binar complet este un copac binar în care toate nodurile de la fiecare nivel sunt complet umplute, cu excepția nodurilor frunze, iar nodurile sunt la fel de stânga.
O grămadă binară sau pur și simplu o grămadă este un arbore binar complet în care elementele sau nodurile sunt stocate într-un mod astfel încât nodul rădăcină să fie mai mare decât cele două noduri copil. Aceasta se numește și heap maxim.
Elementele din heap-ul binar pot fi, de asemenea, stocate ca min-heap, în care nodul rădăcină este mai mic decât cele două noduri secundare ale acestuia. Putem reprezenta o grămadă ca un arbore binar sau o matrice.
În timp ce reprezintă o grămadă ca o matrice, presupunând că indexul începe de la 0, elementul rădăcină este stocat la 0. În general, dacă un nod părinte se află în poziția I, atunci nodul copil stâng se află în poziție (2 * I + 1) și nodul din dreapta este la (2 * I +2).
Algoritm general
Dat mai jos este algoritmul general pentru tehnica sortării heap.
- Construiți un heap maxim din datele date astfel încât rădăcina să fie cel mai înalt element al heap-ului.
- Eliminați rădăcina, adică cel mai înalt element din heap și înlocuiți-l sau schimbați-l cu ultimul element al heap-ului.
- Apoi reglați heap-ul maxim, astfel încât să nu încălcați proprietățile max heap (heapify).
- Pasul de mai sus reduce dimensiunea heap-ului cu 1.
- Repetați cei trei pași de mai sus până când dimensiunea heap-ului este redusă la 1.
Așa cum se arată în algoritmul general pentru a sorta setul de date dat în ordine crescătoare, mai întâi construim un heap maxim pentru datele date.
Să luăm un exemplu pentru a construi un heap maxim cu următorul set de date.
6, 10, 2, 4, 1
Putem construi un arbore pentru acest set de date după cum urmează.
În reprezentarea arborelui de mai sus, numerele din paranteze reprezintă pozițiile respective din matrice.
Pentru a construi o heap maximă din reprezentarea de mai sus, trebuie să îndeplinim condiția heap ca nodul părinte să fie mai mare decât nodurile sale copil. Cu alte cuvinte, trebuie să „heapify” arborele pentru a-l converti în max-heap.
După heapification a arborelui de mai sus, vom obține max-heap așa cum se arată mai jos.
Așa cum se arată mai sus, avem acest max-heap generat dintr-o matrice.
În continuare, vă prezentăm o ilustrare a unui tip de heap. După ce am văzut construcția max-heap, vom sări peste pașii detaliați pentru a construi un max-heap și vom arăta direct heap-ul maxim la fiecare pas.
Ilustrare
Luați în considerare următoarea matrice de elemente. Trebuie să sortăm această matrice folosind tehnica de sortare heap.
Să construim un max-heap așa cum se arată mai jos pentru matricea care urmează să fie sortată.
Odată ce grămada este construită, o reprezentăm într-o formă Array așa cum se arată mai jos.
Acum comparăm 1Sfnod (rădăcină) cu ultimul nod și apoi schimbați-le. Astfel, așa cum se arată mai sus, schimbăm 17 și 3 astfel încât 17 să fie în ultima poziție și 3 să fie în prima poziție.
Acum scoatem nodul 17 din heap și îl punem în matricea sortată așa cum se arată în porțiunea umbrită de mai jos.
Acum construim din nou o grămadă pentru elementele matricei. De această dată, dimensiunea heap-ului este redusă cu 1 deoarece am șters un element (17) din heap.
cum să devii recenzor de jocuri video
Heap-ul elementelor rămase este prezentat mai jos.
În pasul următor, vom repeta aceiași pași.
Comparăm și schimbăm elementul rădăcină și ultimul element din heap.
După schimbare, ștergem elementul 12 din heap și îl mutăm în matricea sortată.
Încă o dată construim un heap maxim pentru elementele rămase așa cum se arată mai jos.
Acum schimbăm rădăcina și ultimul element, adică 9 și 3. După schimbare, elementul 9 este șters din grămadă și pus într-o matrice sortată.
În acest moment, avem doar trei elemente în grămadă, așa cum se arată mai jos.
Schimbăm 6 și 3 și ștergem elementul 6 din heap și îl adăugăm la matricea sortată.
Acum construim o grămadă de elemente rămase și apoi schimbăm ambele între ele.
După schimbarea 4 și 3, ștergem elementul 4 din heap și îl adăugăm la matricea sortată. Acum avem un singur nod rămas în heap, așa cum se arată mai jos .
Deci, acum, cu doar un singur nod rămas, îl ștergem din heap și îl adăugăm la matricea sortată.
Astfel, cele prezentate mai sus sunt matricea sortată pe care am obținut-o ca rezultat al sortării heap.
În ilustrația de mai sus, am sortat matricea în ordine crescătoare. Dacă trebuie să sortăm matricea în ordine descrescătoare, atunci trebuie să urmăm aceiași pași, dar cu min-heap.
Algoritmul Heapsort este identic cu sortarea de selecție în care selectăm cel mai mic element și îl plasăm într-o matrice sortată. Cu toate acestea, sortarea heap este mai rapidă decât sortarea selecției în ceea ce privește performanța. O putem pune, deoarece Hacksort este o versiune îmbunătățită a tipului de selecție.
primele 10 descărcătoare de muzică pentru Android
Apoi, vom implementa Heapsort în limbaj C ++ și Java.
Cea mai importantă funcție în ambele implementări este funcția „heapify”. Această funcție este apelată de rutina principală pentru a rearanja subarborele odată ce un nod este șters sau când este construit max-heap.
Când am adunat în mod corect arborele, doar atunci vom putea obține elementele corecte în pozițiile lor corecte și astfel matricea va fi sortată corect.
Exemplu C ++
Urmează codul C ++ pentru implementarea 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 Ieșire:
Matrice de intrare
4 17 3 12 9 6
Matricea sortată
3 4 6 9 12 17
Apoi, vom implementa Hacksortul în limbajul Java
Exemplu 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 Ieșire:
Matrice de intrare:
4 17 3 12 9 6
Matrice sortate:
3 4 6 9 12 17
Concluzie
Heapsort este o tehnică de sortare bazată pe comparație utilizând heap-ul binar.
Poate fi numită o îmbunătățire față de sortarea de selecție, deoarece ambele tehnici de sortare funcționează cu o logică similară de a găsi în mod repetat cel mai mare sau cel mai mic element din matrice și apoi de a-l plasa în matricea sortată.
Sortarea Heap utilizează max-heap sau min-heap pentru a sorta matricea. Primul pas în sortarea heap este de a construi un heap minim sau maxim din datele matricei și apoi ștergeți elementul rădăcină recursiv și heapify heap până când există un singur nod prezent în heap.
Heapsort este un algoritm eficient și funcționează mai rapid decât sortarea de selecție. Poate fi folosit pentru a sorta o matrice aproape sortată sau pentru a găsi k cele mai mari sau mai mici elemente din matrice.
Cu aceasta, ne-am completat subiectul despre tehnicile de sortare în C ++. Începând cu următorul nostru tutorial, vom începe cu structurile de date unul câte unul.
=> Căutați întreaga serie de formare C ++ aici.
Lectură recomandată