Kaudzes kārtošana ir uz salīdzināšanu balstīta šķirošanas tehnika, kuras pamatā ir Binārā kaudze datu struktūra. Tas ir līdzīgs atlases kārtošana kur vispirms atrodam minimālo elementu un ievietojam minimālo elementu sākumā. Atkārtojiet to pašu procesu pārējiem elementiem.
Kaudzes kārtošanas algoritms
Lai atrisinātu problēmu, izpildiet šādu ideju:
Ieteicamā problēma Lūdzu, vispirms atrisiniet to PRAKSĒ, pirms pārejiet pie risinājuma Atrisināt problēmuVispirms konvertējiet masīvu kaudzes datu struktūrā, izmantojot kaudzes veidošanu, pēc tam pa vienam izdzēsiet Max-heap saknes mezglu un aizstājiet to ar pēdējo kaudzes mezglu un pēc tam izveidojiet kaudzes sakni. Atkārtojiet šo procesu, līdz kaudzes izmērs ir lielāks par 1.
- Izveidojiet kaudzi no dotā ievades masīva.
- Atkārtojiet šīs darbības, līdz kaudzē ir tikai viens elements:
- Apmainiet kaudzes saknes elementu (kas ir lielākais elements) ar pēdējo kaudzes elementu.
- Noņemiet pēdējo kaudzes elementu (kas tagad atrodas pareizajā pozīcijā).
- Salieciet atlikušos kaudzes elementus.
- Sakārtoto masīvu iegūst, mainot elementu secību ievades masīvā.
Detalizēts kaudzes kārtošanas darbs
Lai skaidrāk saprastu kaudzes kārtošanu, ņemsim nešķirotu masīvu un mēģināsim to kārtot, izmantojot kaudzes kārtošanu.
Apsveriet masīvu: arr [] = {4, 10, 3, 5, 1}.Izveidojiet pilnīgu bināro koku: No masīva izveidojiet pilnīgu bināro koku.
Kaudzes kārtošanas algoritms | Izveidojiet pilnīgu bināro koku
Pārveidot par maksimālo kaudzi: Pēc tam uzdevums ir izveidot koku no šī nešķirotā masīva un mēģināt to pārvērst par max kaudze.
string java aizstāt
- Lai pārveidotu kaudzi par maksimālo kaudzi, vecākajam mezglam vienmēr jābūt lielākam par vai vienādam ar pakārtotajiem mezgliem.
- Šeit, šajā piemērā, kā vecāku mezgls 4 ir mazāks par bērna mezglu 10, tādējādi nomainiet tos, lai izveidotu maksimālu kaudzi.
- Tagad 4 jo vecāks ir mazāks par bērnu 5 , tādējādi nomainiet abus vēlreiz, un iegūtajam kaudzei un masīvam vajadzētu būt šādam:
Kaudzes kārtošanas algoritms | Max Heapify konstruēts binārais koks
Veikt kaudzes kārtošanu: Katrā darbībā noņemiet maksimālo elementu (t.i., pārvietojiet to uz beigu pozīciju un noņemiet to) un pēc tam apsveriet atlikušos elementus un pārveidojiet to par maksimālo kaudzi.
- Izdzēsiet saknes elementu (10) no maksimālās kaudzes. Lai dzēstu šo mezglu, mēģiniet to apmainīt ar pēdējo mezglu, t.i. (1). Pēc saknes elementa noņemšanas atkal izveidojiet to kaudzītē, lai pārvērstu to par maksimālo kaudzi.
- Iegūtajai kaudzei un masīvam vajadzētu izskatīties šādi:
Kaudzes kārtošanas algoritms | Noņemiet maksimumu no saknes un maksimālo kaudzi
- Atkārtojiet iepriekš minētās darbības, un tas izskatīsies šādi:
Kaudzes kārtošanas algoritms | Noņemt nākamo maksimumu no saknes un maksimālā kaudze
- Tagad atkal noņemiet sakni (t.i., 3) un veiciet kaudzi.
Kaudzes kārtošanas algoritms | Atkārtojiet iepriekšējo darbību
- Tagad, kad sakne tiek noņemta vēlreiz, tā tiek sakārtota. un sakārtotais masīvs būs kā arr[] = {1, 3, 4, 5, 10} .
Kaudzes kārtošanas algoritms | Galīgais sakārtotais masīvs
Heap Sort ieviešana
C++ // C++ program for implementation of Heap Sort #include using namespace std; // To heapify a subtree rooted with node i // which is an index in arr[]. // n is size of heap void heapify(int arr[], int N, int i) { // Initialize largest as root int largest = i; // left = 2*i + 1 int l = 2 * i + 1; // right = 2*i + 2 int r = 2 * i + 2; // If left child is larger than root if (l < N && arr[l]>arr[lielākais]) lielākais = l; // Ja labais bērns ir lielāks par lielāko // līdz šim if (r< N && arr[r]>arr[lielākais]) lielākais = r; // Ja lielākais nav sakne if (lielākais != i) { swap(arr[i], arr[lielākais]); // Rekursīvi kaudzīt ietekmēto // apakškoku heapify(arr, N, lielākais); } } // Galvenā funkcija kaudzes kārtošanai void heapSort(int arr[], int N) { // Veidot kaudzi (pārkārtot masīvu) for (int i = N / 2 - 1; i>= 0; i--) kaudze(arr, N, i); // Pa vienam izvilkt elementu // no kaudzes for (int i = N - 1; i> 0; i--) { // Pārvietot pašreizējo sakni uz beigu swap(arr[0], arr[i]); // izsaukt max heapify uz samazināto kaudzi heapify(arr, i, 0); } } // Lietderības funkcija n izmēra masīva drukāšanai void printArray(int arr[], int N) { for (int i = 0; i< N; ++i) cout << arr[i] << ' '; cout << '
'; } // Driver's code int main() { int arr[] = { 12, 11, 13, 5, 6, 7 }; int N = sizeof(arr) / sizeof(arr[0]); // Function call heapSort(arr, N); cout << 'Sorted array is
'; printArray(arr, N); }> C // Heap Sort in C #include // Function to swap the position of two elements void swap(int* a, int* b) { int temp = *a; *a = *b; *b = temp; } // To heapify a subtree rooted with node i // which is an index in arr[]. // n is size of heap void heapify(int arr[], int N, int i) { // Find largest among root, // left child and right child // Initialize largest as root int largest = i; // left = 2*i + 1 int left = 2 * i + 1; // right = 2*i + 2 int right = 2 * i + 2; // If left child is larger than root if (left < N && arr[left]>arr[lielākais]) lielākais = pa kreisi; // Ja labais bērns ir lielāks par lielāko // līdz šim if (pa labi< N && arr[right]>arr[lielākais]) lielākais = pa labi; // Apmainīt un turpināt kaudzes veidošanu // ja sakne nav lielākā // Ja lielākā nav sakne if (lielākais != i) { swap(&arr[i], &arr[lielākais]); // Rekursīvi kaudzīt ietekmēto // apakškoku heapify(arr, N, lielākais); } } // Galvenā funkcija kaudzes kārtošanai void heapSort(int arr[], int N) { // Veidot maksimālo kaudzi priekš (int i = N / 2 - 1; i>= 0; i--) heapify(arr , N, i); // Kaudzes kārtošana for (int i = N - 1; i>= 0; i--) { swap(&arr[0], &arr[i]); // Heapify root element // lai iegūtu augstāko elementu // root again heapify(arr, i, 0); } } // Lietderības funkcija n izmēra masīva drukāšanai void printArray(int arr[], int N) { for (int i = 0; i< N; i++) printf('%d ', arr[i]); printf('
'); } // Driver's code int main() { int arr[] = { 12, 11, 13, 5, 6, 7 }; int N = sizeof(arr) / sizeof(arr[0]); // Function call heapSort(arr, N); printf('Sorted array is
'); printArray(arr, N); } // This code is contributed by _i_plus_plus_.> Java // Java program for implementation of Heap Sort public class HeapSort { public void sort(int arr[]) { int N = arr.length; // Build heap (rearrange array) for (int i = N / 2 - 1; i>= 0; i--) kaudze(arr, N, i); // Pa vienam izvilkt elementu no kaudzes for (int i = N - 1; i> 0; i--) { // Pārvietot pašreizējo sakni uz beigām int temp = arr[0]; arr[0] = arr[i]; arr[i] = temp; // izsaukt max heapify uz samazināto kaudzi heapify(arr, i, 0); } } // Lai izveidotu kaudzes apakškoku, kas sakņots ar mezglu i, kas ir // indekss arr[]. n ir kaudzes lielums void heapify(int arr[], int N, int i) { int lielākais = i; // Inicializēt lielāko kā sakni int l = 2 * i + 1; // pa kreisi = 2*i + 1 int r = 2 * i + 2; // pa labi = 2*i + 2 // Ja kreisais bērns ir lielāks par sakni if (l< N && arr[l]>arr[lielākais]) lielākais = l; // Ja labais bērns ir lielāks par lielāko līdz šim if (r< N && arr[r]>arr[lielākais]) lielākais = r; // Ja lielākais nav sakne if (lielākais != i) { int swap = arr[i]; arr[i] = arr[lielākais]; arr[lielākais] = maiņa; // Rekursīvi veidot ietekmēto apakškoku heapify(arr, N, lielākais); } } /* Lietderības funkcija n izmēra masīva drukāšanai */ static void printArray(int arr[]) { int N = arr.length; for (int i = 0; i< N; ++i) System.out.print(arr[i] + ' '); System.out.println(); } // Driver's code public static void main(String args[]) { int arr[] = { 12, 11, 13, 5, 6, 7 }; int N = arr.length; // Function call HeapSort ob = new HeapSort(); ob.sort(arr); System.out.println('Sorted array is'); printArray(arr); } }> C# // C# program for implementation of Heap Sort using System; public class HeapSort { public void sort(int[] arr) { int N = arr.Length; // Build heap (rearrange array) for (int i = N / 2 - 1; i>= 0; i--) kaudze(arr, N, i); // Pa vienam izvilkt elementu no kaudzes for (int i = N - 1; i> 0; i--) { // Pārvietot pašreizējo sakni uz beigām int temp = arr[0]; arr[0] = arr[i]; arr[i] = temp; // izsaukt max heapify uz samazināto kaudzi heapify(arr, i, 0); } } // Lai izveidotu kaudzes apakškoku, kas sakņots ar mezglu i, kas ir // indekss arr[]. n ir kaudzes lielums void heapify(int[] arr, int N, int i) { int lielākais = i; // Inicializēt lielāko kā sakni int l = 2 * i + 1; // pa kreisi = 2*i + 1 int r = 2 * i + 2; // pa labi = 2*i + 2 // Ja kreisais bērns ir lielāks par sakni if (l< N && arr[l]>arr[lielākais]) lielākais = l; // Ja labais bērns ir lielāks par lielāko līdz šim if (r< N && arr[r]>arr[lielākais]) lielākais = r; // Ja lielākais nav sakne if (lielākais != i) { int swap = arr[i]; arr[i] = arr[lielākais]; arr[lielākais] = maiņa; // Rekursīvi veidot ietekmēto apakškoku heapify(arr, N, lielākais); } } /* Lietderības funkcija n izmēra masīva drukāšanai */ static void printArray(int[] arr) { int N = arr.Length; for (int i = 0; i< N; ++i) Console.Write(arr[i] + ' '); Console.Read(); } // Driver's code public static void Main() { int[] arr = { 12, 11, 13, 5, 6, 7 }; int N = arr.Length; // Function call HeapSort ob = new HeapSort(); ob.sort(arr); Console.WriteLine('Sorted array is'); printArray(arr); } } // This code is contributed // by Akanksha Rai(Abby_akku)> Javascript // JavaScript program for implementation // of Heap Sort function sort( arr) { var N = arr.length; // Build heap (rearrange array) for (var i = Math.floor(N / 2) - 1; i>= 0; i--) kaudze(arr, N, i); // Pa vienam izvilkt elementu no kaudzes for (var i = N - 1; i> 0; i--) { // Pārvietot pašreizējo sakni uz beigām var temp = arr[0]; arr[0] = arr[i]; arr[i] = temp; // izsaukt max heapify uz samazināto kaudzi heapify(arr, i, 0); } } // Lai izveidotu kaudzes apakškoku, kas sakņots ar mezglu i, kas ir // indekss arr[]. n ir kaudzes funkcijas lielums heapify(arr, N, i) { var lielākais = i; // Inicializēt lielāko kā sakni var l = 2 * i + 1; // pa kreisi = 2*i + 1 var r = 2 * i + 2; // pa labi = 2*i + 2 // Ja kreisais bērns ir lielāks par sakni if (l< N && arr[l]>arr[lielākais]) lielākais = l; // Ja labais bērns ir lielāks par lielāko līdz šim if (r< N && arr[r]>arr[lielākais]) lielākais = r; // Ja lielākais nav sakne if (lielākais != i) { var swap = arr[i]; arr[i] = arr[lielākais]; arr[lielākais] = maiņa; // Rekursīvi veidot ietekmēto apakškoku heapify(arr, N, lielākais); } } /* Lietderības funkcija n izmēra masīva drukāšanai */ funkcija printArray(arr) { var N = arr.length; for (var i = 0; i< N; ++i) document.write(arr[i] + ' '); } var arr = [12, 11, 13, 5, 6, 7]; var N = arr.length; sort(arr); document.write( 'Sorted array is'); printArray(arr, N); // This code is contributed by SoumikMondal> PHP // Php program for implementation of Heap Sort // To heapify a subtree rooted with node i which is // an index in arr[]. n is size of heap function heapify(&$arr, $N, $i) { $largest = $i; // Initialize largest as root $l = 2*$i + 1; // left = 2*i + 1 $r = 2*$i + 2; // right = 2*i + 2 // If left child is larger than root if ($l < $N && $arr[$l]>$arr[$lielākais]) $lielākais = $l; // Ja labais bērns ir lielāks par lielāko līdz šim if ($r< $N && $arr[$r]>$arr[$lielākais]) $lielākais = $r; // Ja lielākais nav sakne if ($lielākais != $i) { $swap = $arr[$i]; $arr[$i] = $arr[$lielākais]; $arr[$lielākais] = $swap; // Rekursīvi veidot ietekmēto apakškoku kaudzi heapify($arr, $N, $largest); } } // galvenā funkcija kaudzes kārtošanas funkcijai heapSort(&$arr, $N) { // Veidot kaudzi (pārkārtot masīvu) priekš ($i = $N / 2 - 1; $i>= 0; $i- -) heapify($arr, $N, $i); // Pa vienam izvilkt elementu no kaudzes for ($i = $N-1; $i> 0; $i--) { // Pārvietot pašreizējo sakni uz beigām $temp = $arr[0]; $arr[0] = $arr[$i]; $arr[$i] = $temp; // izsaukt max heapify uz samazināto kaudzi heapify($arr, $i, 0); } } /* Lietderības funkcija n izmēra masīva drukāšanai */ function printArray(&$arr, $N) { for ($i = 0; $i< $N; ++$i) echo ($arr[$i].' ') ; } // Driver's program $arr = array(12, 11, 13, 5, 6, 7); $N = sizeof($arr)/sizeof($arr[0]); // Function call heapSort($arr, $N); echo 'Sorted array is ' . '
'; printArray($arr , $N); // This code is contributed by Shivi_Aggarwal ?>>>Python3 Izvade
Sorted array is 5 6 7 11 12 13>
Sarežģītības analīze Kaudzes kārtošana
Laika sarežģītība: O(N log N)
Palīgtelpa: O(log n), sakarā ar rekursīvo zvanu steku. Tomēr iteratīvai ieviešanai palīgtelpa var būt O(1).
Svarīgi punkti par kaudzes kārtošanu:
- Kaudzes kārtošana ir iebūvēts algoritms.
- Tās tipiskā ieviešana nav stabila, bet to var padarīt stabilu (sk šis )
- Parasti 2-3 reizes lēnāk nekā labi īstenots QuickSort . Lēna iemesls ir atsauces vietas trūkums.
Kaudzes šķirošanas priekšrocības:
- Efektīva laika sarežģītība: Kaudzes kārtošanas laika sarežģītība visos gadījumos ir O(n log n). Tas padara to efektīvu lielu datu kopu kārtošanā. The žurnāla n faktors nāk no binārās kaudzes augstuma, un tas nodrošina, ka algoritms saglabā labu veiktspēju pat ar lielu elementu skaitu.
- Atmiņas lietojums - Atmiņas lietojums var būt minimāls (rakstot iteratīvu heapify(), nevis rekursīvu). Tātad, izņemot to, kas ir nepieciešams, lai saglabātu sākotnējo kārtojamo vienumu sarakstu, tai nav nepieciešama papildu atmiņas vieta, lai tā darbotos
- Vienkāršība - Tas ir vienkāršāk saprotams nekā citi tikpat efektīvi kārtošanas algoritmi, jo tajā netiek izmantoti progresīvi datorzinātnes jēdzieni, piemēram, rekursija.
Kaudzes šķirošanas trūkumi:
- Dārgi : kaudzes kārtošana ir dārga, jo konstantes ir augstākas, salīdzinot ar sapludināšanas kārtošanu, pat ja laika sarežģītība abiem ir O(n Log n).
- Nestabils : kaudzes kārtošana ir nestabila. Tas var pārkārtot relatīvo secību.
- Efektīvs: Kaudzes kārtošana nav ļoti efektīva, strādājot ar ļoti sarežģītiem datiem.
Bieži uzdotie jautājumi, kas saistīti ar kaudzes kārtošanu
Q1. Kādas ir divas kaudzes kārtošanas fāzes?
Kaudzes kārtošanas algoritms sastāv no divām fāzēm. Pirmajā fāzē masīvs tiek pārveidots par maksimālo kaudzi. Un otrajā fāzē tiek noņemts augstākais elements (t.i., tas, kas atrodas koka saknē), un atlikušie elementi tiek izmantoti, lai izveidotu jaunu maksimālo kaudzi.
Q2. Kāpēc Heap Sort nav stabils?
Kaudzes kārtošanas algoritms nav stabils algoritms, jo mēs apmainām arr[i] ar arr[0] laukā heapSort (), kas var mainīt līdzvērtīgo atslēgu relatīvo secību.
Q3. Vai Heap Sort ir algoritma sadali un iekaro piemērs?
Kaudzes šķirošana ir NAV vispār sadali un valdi algoritms. Tā izmanto kaudzes datu struktūru, lai efektīvi kārtotu savu elementu, nevis sadali un iekaro pieeju, lai kārtotu elementus.
Q4. Kurš kārtošanas algoritms ir labāks – kaudzes kārtošana vai sapludināšanas kārtošana?
Atbilde slēpjas to laika sarežģītības un telpas prasību salīdzināšanā. Sapludināšanas kārtošana ir nedaudz ātrāka nekā kaudzes kārtošana. Bet, no otras puses, sapludināšanas kārtošana aizņem papildu atmiņu. Atkarībā no prasības jāizvēlas, kuru izmantot.
Q5. Kāpēc kaudzes kārtošana ir labāka par atlases kārtošanu?
binārais koks java
Kaudzes kārtošana ir līdzīga atlases kārtošanai, taču ar labāku veidu, kā iegūt maksimālo elementu. Tas izmanto kaudzes datu struktūras priekšrocības, lai iegūtu maksimālo elementu nemainīgā laikā