Madaling makuha ng programmer ang pinakamataas na elemento sa pamamagitan ng paggamit ng “ Max Heap ” binary tree. Tulad ng sa punong ito, ang pinakamataas na elemento ay laging naninirahan sa tuktok na node ng puno na kilala bilang ' ugat ” node. Bukod dito, nag-aalok ito ng mahusay na pagpasok at pagtanggal ng mga elemento habang pinapanatili ang pinagsunod-sunod na pagkakasunud-sunod. Bilang karagdagan, ang 'Max Heap' ay madaling makakapagsagawa ng mga naka-iskedyul na trabaho batay sa kanilang priyoridad o iba pang pamantayan.
Ipinapaliwanag ng artikulong ito ang sumusunod na nilalaman:
- Paano Gamitin ang Max Heap sa Java?
- Gamitin ang Paraang 'maxHeapify()'.
- Gamitin ang Paraang 'Collections.reverseOrder()'.
Paano Gamitin ang Max Heap sa Java?
isang ' Max Heap ” ay ginagamit bilang pinagbabatayan na istraktura ng data para sa pagpapatupad ng isang priyoridad na pila. Sa priority queue, ang data ay pinoproseso batay sa kanilang nakatalagang priority value. Maaari rin itong magamit upang pag-uri-uriin ang mga elemento ng data sa pababang pagkakasunud-sunod, nang mahusay.
Maaaring mabuo ang 'Max Heap' gamit ang dalawang pamamaraan na inilalarawan kasama ang halimbawa ng codec sa ibaba:
Paraan 1: Gamitin ang Paraang “maxHeapify()”.
Ang ' maxHeapify() 'paraan ay bumubuo ng isang ' Max Heap ” mula sa isang umiiral na koleksyon ng mga elemento sa pamamagitan ng pagbabago ng mga istruktura ng data. Bukod dito, ang pamamaraang ito ay tumutulong sa pagbabago ng orihinal na hanay sa lugar na binabawasan ang pangangailangan para sa karagdagang memorya.
Halimbawa, bisitahin ang code sa ibaba upang makabuo ng ' Max Heap ' gamit ang 'maxHeapify()' na paraan:
import java.util.ArrayList;import java.util.Collections;
import java.util.List;
pampublikong klase MaxHeapifyExam {
pampublikong static void main ( String [ ] args ) // paglikha ng pangunahing ( ) paraan
{
Listahan < Integer > testsEle = bagong ArrayList <> ( ) ;
testEle.add ( 5 ) ;
testEle.add ( 3 ) ;
testEle.add ( 8 ) ;
testEle.add ( 2 ) ;
testEle.add ( 1 ) ;
testEle.add ( 7 ) ;
System.out.println ( 'Orihinal na Listahan: ' + mga pagsubok ) ;
maxHeapify ( MGA PAGSUSULIT ) ;
System.out.println ( 'Ang Max Heap Binuo: ' + mga pagsubok ) ;
}
pribadong static void maxHeapify ( Listahan < Integer > MGA PAGSUSULIT ) {
int k = testEle.size ( ) ;
para sa ( int i = k / 2 - 1 ; i > = 0 ; ako-- ) {
magparami ( testsEle, k, i ) ;
}
}
pribadong static void heapify ( Listahan < Integer > testsEle, int k, int i ) {
int mas malaki = i;
int leftSide = 2 * ako + 1 ;
int rightSide = 2 * ako + 2 ;
kung ( kaliwang bahagi < k && testEle.get ( kaliwang bahagi ) > testEle.get ( mas malaki ) ) {
mas malaki = leftSide;
}
kung ( kanang bahagi < k && testEle.get ( kanang bahagi ) > testEle.get ( mas malaki ) ) {
mas malaki = rightSide;
}
kung ( mas malaki ! = i ) {
Collections.swap ( testsEle, i, mas malaki ) ;
magparami ( testsEle, k, mas malaki ) ;
}
}
}
Paliwanag ng code sa itaas:
- Una, ang listahan ' MGA PAGSUSULIT Ang ” ay pinasimulan gamit ang dummy data elements sa “ pangunahing() ” paraan at naka-print sa console.
- Susunod, ang listahan ng 'testEle' ay ipapasa sa function na 'maxHeapify()', at pagkatapos ay ipapakita ang ibinalik na Listahan sa console.
- Pagkatapos, ang ' maxHeapify() Ang pamamaraan ay pinasimulan at ang laki ng ibinigay na listahan ay nakuha sa pamamagitan ng paggamit ng ' laki() ” paraan.
- Susunod, gamitin ang ' para sa ” loop upang itakda ang istraktura ng heap at kalkulahin ang posisyon ng bawat node.
- Ngayon, gamitin ang ' heapify() ” na paraan at itakda ang posisyon para sa mga 'itaas', 'kaliwa', at 'kanan' na mga node sa pamamagitan ng pagtatalaga ng mga halaga sa mga variable na 'greater', 'leftSide', at 'rightSide', ayon sa pagkakabanggit.
- Pagkatapos nito, gumamit ng maramihang ' kung ' mga kondisyonal na pahayag upang suriin kung ang ' kaliwang bahagi Ang 'node ay mas malaki kaysa sa' kanang bahagi ” node at kabaliktaran. Sa huli, ang mas malaking halaga ay maiimbak sa ' mas malaki ” node.
- Sa wakas, ang bagong ' mas malaki 'Ang halaga ng node ay sinusuri gamit ang nakaimbak na halaga sa ' mas malaki ” variable ng node. At ang ' palitan() Ang function na ” ay gumagana nang naaayon upang itakda ang pinakamalaking halaga sa “ mas malaki ” variable.
Pagkatapos ng pagtatapos ng yugto ng pagpapatupad:
Ipinapakita ng snapshot na ang max heap ay nabuo gamit ang ' maxHeapify() ” paraan sa Java.
Paraan 2: Gamitin ang Paraang “Collections.reverseOrder()”.
Ang ' Collections.reverseOrder() 'paraan ay nag-aalok ng isang simple at maigsi na paraan upang makabuo ng isang ' Max Heap ” sa pamamagitan ng pag-uuri ng koleksyon sa reverse order. Nagbibigay-daan ito sa code na muling gamitin at iniiwasan ang pangangailangang ipatupad ang custom na “ magparami ” logic, tulad ng ipinapakita sa ibaba ng snippet ng code:
import java.util.ArrayList;import java.util.Collections;
import java.util.List;
pampublikong klase ReverseOrderExample {
pampublikong static void main ( String [ ] args ) // paglikha ng pangunahing ( ) paraan
{
Listahan < Integer > testsEle = bagong ArrayList <> ( ) ;
testEle.add ( 5 ) ;
testEle.add ( 38 ) ;
testEle.add ( 98 ) ;
testEle.add ( 26 ) ;
testEle.add ( 1 ) ;
testEle.add ( 73 ) ;
System.out.println ( 'Orihinal na Listahan: ' + testsEle ) ;
Collections.sort ( testsEle, Collections.reverseOrder ( ) ) ;
System.out.println ( 'Ang Max Heap Binuo: ' + testsEle ) ;
}
}
Paliwanag ng code sa itaas:
- Una, i-import ang ' ArrayList ”, “ Mga koleksyon 'at' Listahan ” mga utility sa Java file.
- Pagkatapos, lumikha ng ' Listahan ' pinangalanan ' MGA PAGSUSULIT ” at ipasok ang mga dummy na elemento sa listahan.
- Susunod, ang ' sort() Ang paraan ng ” ay ginagamit upang pag-uri-uriin ang mga elemento ng data sa pataas na pagkakasunud-sunod at ipasa ang listahan bilang isang parameter kasama ang “ Collections.reverseOrder() ” paraan. Ginagawa nito ang pag-uuri ng ' MGA PAGSUSULIT ” listahan sa reverse order.
Pagkatapos ng pagtatapos ng yugto ng pagpapatupad:
Ang snapshot ay nagpapakita na ang 'Max Heap' ay nabuo at pinagsunod-sunod gamit ang 'Collections.reverseOrder()' na paraan.
Konklusyon
Sa pamamagitan ng paglikha ng ' Max Heap ”, maaaring gamitin ng mga user ang mga pamamaraang “maxHeapify()” at “Collections.reverseOrder()”. Pinamamahalaan nila ang isang koleksyon ng mga elemento sa paraang nagbibigay-daan sa mabilis na pag-access sa pinakamataas na elemento at mahusay na pagpapanatili ng isang pinagsunod-sunod na order. Ito ay nakasalalay lamang sa mga partikular na kinakailangan at antas ng kontrol na kailangan sa proseso ng paggawa ng heap.