HEAP SORT - DATASTRUKTURER OG ALGORITMER TUTORIALS - TECHCODEVIEW.COM

Dynge sortering er en sammenligningsbaseret sorteringsteknik baseret på Binær bunke datastruktur. Det ligner udvælgelsessortering hvor vi først finder minimumselementet og placerer minimumelementet i begyndelsen. Gentag den samme proces for de resterende elementer.

Dyngesorteringsalgoritme

Følg nedenstående idé for at løse problemet:

Konverter først arrayet til heap-datastruktur ved hjælp af heapify, og slet derefter én efter én rodknuden på Max-heapen og erstat den med den sidste node i heapen og heap derefter roden af heapen. Gentag denne proces, indtil bunkens størrelse er større end 1.

Byg en bunke fra det givne input-array.
Gentag følgende trin, indtil heapen kun indeholder ét element:
Byt rodelementet af bunken (som er det største element) med det sidste element i bunken.
Fjern det sidste element af bunken (som nu er i den rigtige position).
Ophob de resterende elementer af heapen.
Det sorterede array opnås ved at vende rækkefølgen af elementerne i input-arrayet.

Anbefalet problem Løs det venligst på PRAKTISK først, før du går videre til løsningen Løs problem

Detaljeret bearbejdning af bunkesortering

For at forstå heap-sortering mere klart, lad os tage et usorteret array og prøve at sortere det ved hjælp af heap-sortering.
Overvej matrixen: arr[] = {4, 10, 3, 5, 1}.

Byg komplet binært træ: Byg et komplet binært træ fra arrayet.

Heap-sorteringsalgoritme | Byg komplet binært træ
nat vs seng

Omdannes til max heap: Derefter er opgaven at konstruere et træ fra det usorterede array og forsøge at konvertere det til max bunke.

For at transformere en heap til en max-heap, skal den overordnede node altid være større end eller lig med de underordnede noder
Her, i dette eksempel, som overordnet node 4 er mindre end børneknuden 10, byt dem derfor for at bygge en max-heap.
Nu, 4 som forælder er mindre end barnet 5 , så skift begge disse igen, og den resulterende heap og array skulle være sådan:

Heap-sorteringsalgoritme | Max Heapify konstrueret binært træ

Udfør bunkesortering: Fjern det maksimale element i hvert trin (dvs. flyt det til slutpositionen og fjern det), og overvej derefter de resterende elementer og transformer det til en maks. bunke.

Slet rodelementet (10) fra den maksimale bunke. For at slette denne node, prøv at bytte den med den sidste node, dvs. (1). Når du har fjernet rodelementet, skal du igen heapify det for at konvertere det til max heap.
Den resulterende heap og array skulle se sådan ud:

Heap-sorteringsalgoritme | Fjern maksimum fra root og max heapify
omdøbe mappen linux

Gentag ovenstående trin, og det vil se sådan ud:

Heap-sorteringsalgoritme | Fjern næste maksimum fra root nad max heapify

Fjern nu roden (dvs. 3) igen og udfør heapify.

Heap-sorteringsalgoritme | Gentag forrige trin

Når nu roden er fjernet igen, er den sorteret. og det sorterede array vil være som arr[] = {1, 3, 4, 5, 10} .

Heap-sorteringsalgoritme | Endelig sorteret array

Implementering af Heap Sort

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[størst]) største = l;  // Hvis højre barn er større end størst // indtil videre hvis (r< N && arr[r]>arr[størst]) største = r;  // Hvis største ikke er root if (størst != i) { swap(arr[i], arr[størst]);  // Heapify rekursivt det berørte // sub-tree heapify(arr, N, størst);  } } // Hovedfunktion til at udføre heap sortering void heapSort(int arr[], int N) { // Byg heap (omarranger array) for (int i = N / 2 - 1; i>= 0; i--) heapify(arr, N, i);  // En efter en udtræk et element // fra heap for (int i = N - 1; i> 0; i--) { // Flyt nuværende rod for at afslutte swap(arr[0], arr[i]);  // kald max heapify på den reducerede heap heapify(arr, i, 0);  } } // En hjælpefunktion til at udskrive array af størrelse n 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); }>

 // 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[største]) største = venstre;  // Hvis højre barn er større end størst // indtil videre hvis (højre< N && arr[right]>arr[størst]) største = højre;  // Byt og fortsæt med at heapify // hvis rod ikke er størst // Hvis største ikke er rod if (størst != i) { swap(&arr[i], &arr[størst]);  // Heapify rekursivt det berørte // sub-tree heapify(arr, N, størst);  } } // Hovedfunktion til at udføre heap sortering void heapSort(int arr[], int N) { // Byg max heap for (int i = N / 2 - 1; i>= 0; i--) heapify(arr N, i);  // Heap sort for (int i = N - 1; i>= 0; i--) { swap(&arr[0], &arr[i]);  // Heapify root element // for at få det højeste element ved // root igen heapify(arr, i, 0);  } } // En hjælpefunktion til at udskrive array af størrelse n 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--) heapify(arr, N, i);  // En efter en ekstraherer et element fra heap for (int i = N - 1; i> 0; i--) { // Flyt nuværende rod til slutningen int temp = arr[0];  arr[0] = arr[i];  arr[i] = temp;  // kald max heapify på den reducerede heap heapify(arr, i, 0);  } } // At heapify et undertræ med rod med node i, som er // et indeks i arr[]. n er størrelsen af heap void heapify(int arr[], int N, int i) { int største = i; // Initialiser størst som root int l = 2 * i + 1; // venstre = 2*i + 1 int r = 2 *i + 2; // højre = 2*i + 2 // Hvis venstre barn er større end root if (l< N && arr[l]>arr[størst]) største = l;  // Hvis højre barn er større end hidtil størst, hvis (r< N && arr[r]>arr[størst]) største = r;  // Hvis størst ikke er root if (størst != i) { int swap = arr[i];  arr[i] = arr[størst];  arr[største] = bytte;  // Heapify rekursivt det berørte undertræ heapify(arr, N, størst);  } } /* En hjælpefunktion til at udskrive array af størrelse n */ 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# 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--) heapify(arr, N, i);  // En efter en ekstraherer et element fra heap for (int i = N - 1; i> 0; i--) { // Flyt nuværende rod til slutningen int temp = arr[0];  arr[0] = arr[i];  arr[i] = temp;  // kald max heapify på den reducerede heap heapify(arr, i, 0);  } } // At heapify et undertræ med rod med node i, som er // et indeks i arr[]. n er størrelsen af heap void heapify(int[] arr, int N, int i) { int største = i; // Initialiser størst som root int l = 2 * i + 1; // venstre = 2*i + 1 int r = 2 *i + 2; // højre = 2*i + 2 // Hvis venstre barn er større end root if (l< N && arr[l]>arr[størst]) største = l;  // Hvis højre barn er større end hidtil størst, hvis (r< N && arr[r]>arr[størst]) største = r;  // Hvis størst ikke er root if (størst != i) { int swap = arr[i];  arr[i] = arr[størst];  arr[største] = bytte;  // Heapify rekursivt det berørte undertræ heapify(arr, N, størst);  } } /* En hjælpefunktion til at udskrive array af størrelse n */ 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--) heapify(arr, N, i);  // En efter en udtræk et element fra heap for (var i = N - 1; i> 0; i--) { // Flyt nuværende rod til slutningen var temp = arr[0];  arr[0] = arr[i];  arr[i] = temp;  // kald max heapify på den reducerede heap heapify(arr, i, 0);  } } // At heapify et undertræ med rod med node i, som er // et indeks i arr[]. n er størrelsen af heap-funktionen heapify(arr, N, i) { var største = i; // Initialiser størst som root var l = 2 * i + 1; // venstre = 2*i + 1 var r = 2 *i + 2; // højre = 2*i + 2 // Hvis venstre barn er større end root if (l< N && arr[l]>arr[størst]) største = l;  // Hvis højre barn er større end hidtil størst, hvis (r< N && arr[r]>arr[størst]) største = r;  // Hvis størst ikke er root if (størst != i) { var swap = arr[i];  arr[i] = arr[størst];  arr[største] = bytte;  // Heapify rekursivt det berørte undertræ heapify(arr, N, størst);  } } /* En hjælpefunktion til at udskrive array af størrelse n */ function 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[$største]) $største = $l; // Hvis højre barn er større end hidtil størst, hvis ($r< $N && $arr[$r]>$arr[$største]) $største = $r; // Hvis største ikke er root if ($largest != $i) { $swap = $arr[$i]; $arr[$i] = $arr[$største]; $arr[$største] = $swap; // Heapify rekursivt det berørte undertræ heapify($arr, $N, $største); } } // hovedfunktion til at udføre heap-sorteringsfunktion heapSort(&$arr, $N) { // Byg heap (omarranger array) for ($i = $N / 2 - 1; $i>= 0; $i- -) heapify($arr, $N, $i); // En efter en udtræk et element fra heap for ($i = $N-1; $i> 0; $i--) { // Flyt nuværende rod til slutningen $temp = $arr[0]; $arr[0] = $arr[$i]; $arr[$i] = $temp; // kald max heapify på den reducerede heap heapify($arr, $i, 0); } } /* En hjælpefunktion til at udskrive array af størrelse n */ 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

 # Python program for implementation of heap Sort # To heapify subtree rooted at index i. # n is size of heap def 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 # See if left child of root exists and is # greater than root if l < N and arr[largest] < arr[l]: largest = l # See if right child of root exists and is # greater than root if r < N and arr[largest] < arr[r]: largest = r # Change root, if needed if largest != i: arr[i], arr[largest] = arr[largest], arr[i] # swap # Heapify the root. heapify(arr, N, largest) # The main function to sort an array of given size def heapSort(arr): N = len(arr) # Build a maxheap. for i in range(N//2 - 1, -1, -1): heapify(arr, N, i) # One by one extract elements for i in range(N-1, 0, -1): arr[i], arr[0] = arr[0], arr[i] # swap heapify(arr, i, 0) # Driver's code if __name__ == '__main__': arr = [12, 11, 13, 5, 6, 7] # Function call heapSort(arr) N = len(arr) print('Sorted array is') for i in range(N): print('%d' % arr[i], end=' ') # This code is contributed by Mohit Kumra>

Produktion

Sorted array is 5 6 7 11 12 13>

Kompleksitetsanalyse af Dynge sortering

Tidskompleksitet: O(N log N)
Hjælpeplads: O(log n), på grund af den rekursive opkaldsstak. Hjælperum kan dog være O(1) til iterativ implementering.

Vigtige punkter om Heap Sort:

Heap sort er en in-place algoritme.
Dens typiske implementering er ikke stabil, men kan gøres stabil (se det her )
Typisk 2-3 gange langsommere end velimplementeret QuickSort . Årsagen til langsommelighed er manglende referencelokalitet.

Fordele ved Heap Sort:

Effektiv tidskompleksitet: Heap Sort har en tidskompleksitet på O(n log n) i alle tilfælde. Dette gør det effektivt til sortering af store datasæt. Det log n faktor kommer fra højden af den binære heap, og den sikrer, at algoritmen bevarer en god ydeevne selv med et stort antal elementer.
Hukommelsesbrug – Hukommelsesbrug kan være minimal (ved at skrive en iterativ heapify() i stedet for en rekursiv). Så bortset fra det, der er nødvendigt for at holde den indledende liste over elementer, der skal sorteres, behøver den ingen ekstra hukommelsesplads for at fungere
Enkelhed – Det er lettere at forstå end andre lige så effektive sorteringsalgoritmer, fordi det ikke bruger avancerede datavidenskabelige begreber såsom rekursion.

Ulemper ved Heap Sort:

Kostbar : Dyngesortering er dyr, da konstanterne er højere sammenlignet med flettesortering, selvom tidskompleksiteten er O(n Log n) for begge.
Ustabil : Dyngesortering er ustabil. Det kan omarrangere den relative rækkefølge.
Effektiv: Heap Sort er ikke særlig effektiv, når der arbejdes med meget komplekse data.

Ofte stillede spørgsmål relateret til Heap Sort

Q1. Hvad er de to faser af Heap Sort?

np betyder

Heap-sorteringsalgoritmen består af to faser. I den første fase konverteres arrayet til en max heap. Og i den anden fase fjernes det højeste element (dvs. det ved træroden), og de resterende elementer bruges til at skabe en ny max-bunke.

Q2. Hvorfor er Heap Sort ikke stabil?

Heap-sorteringsalgoritmen er ikke en stabil algoritme, fordi vi bytter arr[i] med arr[0] i heapSort(), hvilket kan ændre den relative rækkefølge af de tilsvarende nøgler.

Q3. Er Heap Sort et eksempel på Divide and Conquer-algoritmen?

Dynge slags er IKKE overhovedet en Divide and Conquer-algoritme. Den bruger en heap-datastruktur til effektivt at sortere dets element og ikke en opdel og hersk tilgang til at sortere elementerne.

Q4. Hvilken sorteringsalgoritme er bedre - Heap-sortering eller Merge Sort?

linux ændringsfil

Svaret ligger i sammenligningen af deres tidskompleksitet og pladsbehov. Merge-sorteringen er lidt hurtigere end Heap-sorteringen. Men på den anden side tager merge sort ekstra hukommelse. Afhængigt af kravet bør man vælge, hvilken man vil bruge.

Q5. Hvorfor er Heap-sortering bedre end Selection-sortering?

Heap-sortering ligner udvalgssortering, men med en bedre måde at få det maksimale element på. Det udnytter heap-datastrukturen til at få det maksimale element på konstant tid

TechCodeview

Heap Sort – Datastrukturer og algoritmer tutorials