Johdanto Java-lajitteluun
Heapsort Java -sovelluksessa on vertailupohjainen lajittelutekniikka, jossa käytetään datarakennetta Binary Heap. Tämä lajittelu on melkein sama kuin valintalajittelu, jossa valitaan suurin elementti ja asetetaan lopussa ja prosessi toistetaan kaikille elementeille. Ymmärtääksemme Heap Sortin, katsotaanpa mitä Java-binaarinen Heap Sort.
- Puupohjainen tietorakenne.
- Täydellinen binaaripuu.
- Sillä voi olla korkeintaan kaksi lasta.
- Juurisolmun arvo voi olla suurempi (Max Heap) tai pienempi (Min Heap)
Kuinka Heap Sort toimii Java-versiossa?
Ennen kuin siirrymme algoritmiin, katsotaan mikä on Heapify.
HEAPIFY
Kun kasa on luotu syöttötiedoilla, kasan ominaisuus ei ehkä ole tyytyväinen. Sen saavuttamiseksi kasan solmuja säädetään funktiolla nimeltään heapify. Jos haluamme luoda maksimikasan, nykyistä elementtiä verrataan sen lapsiin ja jos lasten arvo on suurempi kuin nykyinen elementti, vaihtaminen tapahtuu vasemman tai oikean lapsen suurimmalla elementillä. Samoin, jos min-kasa on luotava, vaihtaminen tapahtuu vasemman tai oikean lapsen pienimmällä osalla. Esimerkiksi, seuraava on syöttöryhmämme,
Voimme pitää tätä puuna taulukon sijasta. Ensimmäinen elementti on juuri, toinen on vasemman juuren lapsi, kolmas osa on juuri oikea lapsi ja niin edelleen.
Jotta kasa muuttuisi puuksi, siirrä puuta alhaalta ylöspäin. Koska lehtisolmukkeilla ei ole lapsia, tutkitaan seuraavaa tasoa. eli on 5 ja 7.
Voimme aloittaa klo 5, koska se on vasemmalla. Tässä 5: llä on kaksi lasta: 9 ja 4, missä 9 on suurempi kuin emo-solmu 5. Jos haluat tehdä vanhemmista suurempia, vaihdamme 5 ja 9. Vaihdon jälkeen puu on alla olevan kuvan mukainen.
Siirrytään seuraavaan elementtiin 7, jossa 8 ja 2 ovat lapsia. Samanlaisia elementtejä 9 ja 4, 7 ja 8 vaihdetaan kuten alla olevassa puussa.
Lopuksi 3: lla on kaksi lasta-9 ja 8, joissa 9 on suurempi lasten keskuudessa ja juuri. Joten vaihdetaan 3 ja 9, jotta juuri saadaan suurempi. Toista prosessi, kunnes muodostetaan kelvollinen kasa alla olevan kuvan mukaisesti.
Algoritmi kasaan lajittelu nousevassa järjestyksessä
- Luo syöttötiedoilla Max Heap
- Korvaa viimeinen elementti kasan suurimmalla elementillä
- Kasvata puu
- Toista prosessi, kunnes taulukko on lajiteltu
Algoritmi kasaan lajittelu alenevassa järjestyksessä
- Luo minisäde tulotiedoilla
- Korvaa viimeinen elementti pienimmällä elementillä kasassa
- Kasvata puu
- Toista prosessi, kunnes taulukko on lajiteltu
Yritäkäämme nyt yrittää lajitella yllä saatu kasa nousevassa järjestyksessä annetun algoritmin avulla. Poista ensin suurin elementti. eli juuri ja korvata se viimeisellä elementillä.
Nyt kasaan muodostettava puu ja aseta poistettu elementti taulukon viimeiseen osaan alla olevan kuvan mukaisesti
Poista jälleen juurelementti, korvaa se viimeisellä elementillä ja Heapify se.
Aseta irrotettu elementti vapaaseen asentoon. Nyt voit nähdä, että taulukon loppu on lajiteltu.
Poista nyt elementti 7 ja korvaa se 2: lla.
Puu kasvattaa alla olevan kuvan mukaisesti.
Toista prosessi, kunnes taulukko on lajiteltu. Elementin 5 poistaminen.
Puun kasvattaminen.
Elementin 4 poistaminen.
Heapfying taas.
Viimeinkin muodostetaan tällainen lajiteltu taulukko.
Esimerkkejä Heap Sort -sovelluksen toteuttamisesta Java-sovelluksessa
Katsotaanpa nyt Java-versiossa Heap Sort -koodia
//Java program to sort the elements using Heap sort
import java.util.Arrays;
public class HeapSort (
public void sort(int array()) (
int size = array.length; //Assigning the length of array in a variable
// Create heap
for (int i = size / 2 - 1; i >= 0; i--)
heapify(array, size, i);
//Find the maximum element and replace it with the last element in the array
for (int i=size-1; i>=0; i--) (
int x = array(0);//largest element(It is available in the root)
array(0) = array(i);
array(i) = x;
// Recursively call heapify until a heap is formed
heapify(array, i, 0);
)
)
// Heapify function
void heapify(int array(), int SizeofHeap, int i) (
int largestelement = i; // Set largest element as root
int leftChild = 2*i + 1; // index of left child = 2*i + 1
int rightChild = 2*i + 2; //index of right child = 2*i + 2
// left child is greater than root
if (leftChild array(largestelement))
largestelement = leftChild ;
//right child is greater than largest
if (rightChild array(largestelement))
largestelement = rightChild ;
// If largestelement is not root
if (largestelement != i) (
int temp = array(i);
array(i) = array(largestelement);
array(largestelement) = temp;
// Recursive call to heapify the sub-tree
heapify(array, SizeofHeap, largestelement);
)
)
public static void main(String args()) (
int array() = (3, 5, 7, 9, 4, 8, 2);
System. out .println("Input array is: " + Arrays. toString (array));
HeapSort obj = new HeapSort();
obj.sort(array);
System. out .println("Sorted array is : " + Arrays. toString (array));
)
)
ulostulo
johtopäätös
Heap Sort on lajittelumenetelmä, joka riippuu binaarisen kasan datarakenteesta. Se on melkein samanlainen kuin valintalajittelu, eikä siinä käytetä erillisiä taulukkoja lajitteluun ja kasaan.
Suositeltava artikkeli
Tämä on opas Heap Sortista Java-sovelluksessa. Tässä keskustellaan toimivasta, lajittelualgoritmista nousevan ja laskevan järjestyksen kanssa ja esimerkkeistä näytekoodilla. Voit myös käydä läpi muiden ehdotettujen artikkeleidemme saadaksesi lisätietoja -
- JavaScript-matematiikan toiminnot
- Asettelu Java-tilassa
- Java-kääntäjät
- Opas yhdistämään Java-lajittelu
- Opas Heap-lajitteluun C: ssä
- Esimerkkejä kasalajittelu C ++: ssa