heap sort c with examples
En introduktion til dynesortering med eksempler.
Heapsort er en af de mest effektive sorteringsteknikker. Denne teknik bygger en bunke fra det givne usorterede array og bruger derefter bunken igen til at sortere arrayet.
Heapsort er en sorteringsteknik baseret på sammenligning og bruger binær bunke.
=> Læs gennem Easy C ++ træningsserien.
top 10 markedsundersøgelsesvirksomheder i verden
Hvad du vil lære:
- Hvad er en binær bunke?
- Generel algoritme
- Illustration
- C ++ Eksempel
- Java-eksempel
- Konklusion
- Anbefalet læsning
Hvad er en binær bunke?
En binær bunke er repræsenteret ved hjælp af et komplet binært træ. Et komplet binært træ er et binært træ, hvor alle knudepunkterne på hvert niveau er fuldstændigt udfyldt bortset fra bladknudepunkterne og knudepunkterne er så langt som til venstre.
En binær bunke eller simpelthen en bunke er et komplet binært træ, hvor elementerne eller noder er gemt på en sådan måde, at rodnoden er større end dens to undernoder. Dette kaldes også max heap.
Elementerne i den binære bunke kan også gemmes som min-bunke, hvor rodknudepunktet er mindre end dets to undernoder. Vi kan repræsentere en bunke som et binært træ eller en matrix.
Mens det repræsenterer en bunke som en matrix, forudsat at indekset starter ved 0, lagres rodelementet ved 0. Generelt, hvis en overordnet node er i positionen I, er den venstre barneknude i positionen (2 * I + 1) og den højre knude er ved (2 * I +2).
Generel algoritme
Nedenfor er den generelle algoritme for bunksorteringsteknik.
- Byg en maksimal bunke fra de givne data, så roden er det højeste element i bunken.
- Fjern roden, dvs. det højeste element fra bunken, og udskift eller skift det med det sidste element i bunken.
- Juster derefter max heap for ikke at krænke max heap egenskaber (heapify).
- Ovenstående trin reducerer bunkestørrelsen med 1.
- Gentag ovenstående tre trin, indtil dyngestørrelsen er reduceret til 1.
Som vist i den generelle algoritme til at sortere det givne datasæt i stigende rækkefølge, konstruerer vi først en maksimal bunke til de givne data.
Lad os tage et eksempel på at konstruere en maksimal bunke med følgende datasæt.
6, 10, 2, 4, 1
Vi kan konstruere et træ til dette datasæt som følger.
I ovenstående trærepræsentation repræsenterer tallene i parenteser de respektive positioner i arrayet.
For at konstruere en maksimal bunke af ovenstående repræsentation er vi nødt til at opfylde bunkebetingelsen om, at den overordnede node skal være større end dens underordnede noder. Med andre ord er vi nødt til at 'heapify' træet for at konvertere det til max-heap.
Efter heapificering af ovenstående træ får vi max-bunken som vist nedenfor.
Som vist ovenfor har vi genereret denne max-heap fra en matrix.
Dernæst præsenterer vi en illustration af en bunksort. Efter at have set konstruktionen af max-heap springer vi de detaljerede trin over for at konstruere en max-heap og viser direkte den maksimale bunke ved hvert trin.
Illustration
Overvej følgende række elementer. Vi er nødt til at sortere denne matrix ved hjælp af heapsorteringsteknikken.
Lad os konstruere en max-heap som vist nedenfor for det array, der skal sorteres.
Når bunken er konstrueret, repræsenterer vi den i en matrixform som vist nedenfor.
Nu sammenligner vi 1St.knude (rod) med den sidste knude, og skift dem derefter. Som vist ovenfor bytter vi således 17 og 3, så 17 er i den sidste position og 3 er i den første position.
Nu fjerner vi knudepunktet 17 fra bunken og lægger det i det sorterede array som vist i den skyggefulde del nedenfor.
Nu konstruerer vi igen en bunke til matrixelementerne. Denne gang reduceres dyngestørrelsen med 1, da vi har slettet et element (17) fra bunken.
bedste gratis stemmeskifter til uoverensstemmelse
Bunken af de resterende elementer er vist nedenfor.
I det næste trin gentager vi de samme trin.
Vi sammenligner og bytter rodelementet og det sidste element i bunken.
Efter bytte sletter vi elementet 12 fra bunken og skifter det til det sorterede array.
Endnu en gang konstruerer vi en maksimal bunke til de resterende elementer som vist nedenfor.
Nu bytter vi roden og det sidste element, dvs. 9 og 3. Efter bytte slettes element 9 fra bunken og placeres i et sorteret array.
På dette tidspunkt har vi kun tre elementer i bunken som vist nedenfor.
Vi bytter 6 og 3 og sletter elementet 6 fra bunken og føjer det til det sorterede array.
Nu konstruerer vi en bunke af de resterende elementer og bytter derefter begge med hinanden.
Efter at have byttet 4 og 3 sletter vi element 4 fra bunken og føjer det til det sorterede array. Nu har vi kun en node tilbage i bunken som vist nedenfor .
Så nu med kun én node tilbage, sletter vi den fra bunken og føjer den til det sorterede array.
Således er ovenstående det sorterede array, som vi har opnået som et resultat af heap-sorteringen.
I ovenstående illustration har vi sorteret arrayet i stigende rækkefølge. Hvis vi skal sortere arrayet i faldende rækkefølge, er vi nødt til at følge de samme trin, men med min-bunken.
Heapsort-algoritme er identisk med valgsortering, hvor vi vælger det mindste element og placerer det i et sorteret array. Heapsortering er dog hurtigere end sorteringssortering for så vidt angår ydeevnen. Vi kan sige det, da heapsort er en forbedret version af sortimentet.
typer bugs i softwaretest
Dernæst implementerer vi Heapsort på C ++ og Java-sprog.
Den vigtigste funktion i begge implementeringer er funktionen “heapify”. Denne funktion kaldes af den primære heapsort-rutine til at omarrangere undertræret, når en node er slettet, eller når max-heap er bygget.
Når vi har heapificeret træet korrekt, vil vi først kunne få de korrekte elementer i deres rette positioner, og dermed vil arrayet blive sorteret korrekt.
C ++ Eksempel
Følgende er C ++ -koden til implementering af 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 Produktion:
Input array
4 17 3 12 9 6
Sorteret matrix
3 4 6 9 12 17
Dernæst implementerer vi heapsort på Java-sprog
Java-eksempel
// 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 Produktion:
Input array:
4 17 3 12 9 6
Sorteret matrix:
3 4 6 9 12 17
Konklusion
Heapsort er en sammenligningsbaseret sorteringsteknik ved hjælp af binær bunke.
Det kan betegnes som en forbedring i forhold til markeringssortering, da begge disse sorteringsteknikker fungerer med samme logik for at finde det største eller mindste element i arrayet gentagne gange og derefter placere det i det sorterede array.
Heap sort bruger max-heap eller min-heap til at sortere arrayet. Det første trin i heap-sortering er at opbygge en min- eller max-bunke fra array-dataene og derefter slette rodelementet rekursivt og heapify bunken, indtil der kun er en node til stede i bunken.
Heapsort er en effektiv algoritme, og den fungerer hurtigere end valg af sortering. Det kan bruges til at sortere et næsten sorteret array eller finde k største eller mindste elementer i arrayet.
Med dette har vi afsluttet vores emne om sorteringsteknikker i C ++. Fra og med vores næste tutorial begynder vi med datastrukturer en efter en.
=> Se efter hele C ++ træningsserien her.
Anbefalet læsning
- MongoDB Sort () metode med eksempler
- Unix sorteringskommando med syntaks, indstillinger og eksempler
- Flet sortering i C ++ med eksempler
- Shell Sort In C ++ med eksempler
- Indsats sortering i C ++ med eksempler
- Valg af sortering i C ++ med eksempler
- Boblesortering i C ++ med eksempler
- Hurtig sortering i C ++ med eksempler