ప్రోగ్రామర్ 'ని ఉపయోగించడం ద్వారా గరిష్ట మూలకాన్ని సులభంగా తిరిగి పొందవచ్చు గరిష్ట కుప్ప ” బైనరీ చెట్టు. ఈ చెట్టులో వలె, గరిష్ట మూలకం ఎల్లప్పుడూ చెట్టు ఎగువ నోడ్‌లో నివసిస్తుంది, దీనిని ' రూట్ ' నోడ్. అంతేకాకుండా, ఇది క్రమబద్ధీకరించబడిన క్రమాన్ని కొనసాగిస్తూ ఎలిమెంట్‌లను సమర్థవంతంగా చొప్పించడం మరియు తొలగించడాన్ని అందిస్తుంది. అదనంగా, 'మాక్స్ హీప్' వారి ప్రాధాన్యత లేదా ఇతర ప్రమాణాల ఆధారంగా షెడ్యూల్ చేసిన ఉద్యోగాలను సులభంగా నిర్వహించగలదు.
ఈ వ్యాసం కింది కంటెంట్‌ను వివరిస్తుంది:
- జావాలో మాక్స్ హీప్ ఎలా ఉపయోగించాలి?
- “maxHeapify()” పద్ధతిని ఉపయోగించండి
- “Collections.reverseOrder()” పద్ధతిని ఉపయోగించండి
జావాలో మాక్స్ హీప్ ఎలా ఉపయోగించాలి?
ఎ' గరిష్ట కుప్ప ” ప్రాధాన్యతా క్రమాన్ని అమలు చేయడానికి అంతర్లీన డేటా నిర్మాణంగా ఉపయోగించబడుతుంది. ప్రాధాన్యత క్యూలో, డేటా వారి కేటాయించిన ప్రాధాన్యత విలువ ఆధారంగా ప్రాసెస్ చేయబడుతుంది. డేటా మూలకాలను అవరోహణ క్రమంలో సమర్ధవంతంగా క్రమబద్ధీకరించడానికి కూడా దీనిని ఉపయోగించవచ్చు.
దిగువ కోడెక్ ఉదాహరణలో వివరించబడిన రెండు పద్ధతులను ఉపయోగించి 'మాక్స్ హీప్'ని రూపొందించవచ్చు:
విధానం 1: “maxHeapify()” పద్ధతిని ఉపయోగించండి
ది ' maxHeapify() 'పద్ధతి ఒక' ఉత్పత్తి చేస్తుంది గరిష్ట కుప్ప డేటా నిర్మాణాలను మార్చడం ద్వారా ఇప్పటికే ఉన్న మూలకాల సేకరణ నుండి. అంతేకాకుండా, అదనపు మెమరీ అవసరాన్ని తగ్గించడం ద్వారా అసలు శ్రేణిని సవరించడంలో ఈ పద్ధతి సహాయపడుతుంది.
ఉదాహరణకు, ''ని రూపొందించడానికి క్రింది కోడ్‌ని సందర్శించండి గరిష్ట కుప్ప 'maxHeapify()' పద్ధతిని ఉపయోగించి:
java.util.ArrayListని దిగుమతి చేయండి;java.util.Collections దిగుమతి;
java.util.Listని దిగుమతి చేయండి;
పబ్లిక్ క్లాస్ MaxHeapifyExam {
పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) // ప్రధాన సృష్టి ( ) పద్ధతి
{
జాబితా < పూర్ణ సంఖ్య > testsEle = కొత్త అర్రేలిస్ట్ <> ( ) ;
testEle.add ( 5 ) ;
testEle.add ( 3 ) ;
testEle.add ( 8 ) ;
testEle.add ( 2 ) ;
testEle.add ( 1 ) ;
testEle.add ( 7 ) ;
System.out.println ( 'అసలు జాబితా:' + పరీక్షలు ) ;
maxHeapify ( పరీక్షలు ) ;
System.out.println ( 'మాక్స్ హీప్ ఉత్పత్తి చేయబడింది:' + పరీక్షలు ) ;
}
ప్రైవేట్ స్టాటిక్ శూన్యత maxHeapify ( జాబితా < పూర్ణ సంఖ్య > పరీక్షలు ) {
int k = testEle.size ( ) ;
కోసం ( int i = k / 2 - 1 ; i > = 0 ; నేను-- ) {
పోగుచేయు ( testsEle, k, i ) ;
}
}
ప్రైవేట్ స్టాటిక్ శూన్యత హెపిఫై ( జాబితా < పూర్ణ సంఖ్య > testsEle, int k, int i ) {
int greater = నేను;
int leftSide = 2 * నేను + 1 ;
int rightSide = 2 * నేను + 2 ;
ఉంటే ( ఎడమ వైపు < కె && testEle.get ( ఎడమ వైపు ) > testEle.get ( ఎక్కువ ) ) {
ఎక్కువ = ఎడమవైపు;
}
ఉంటే ( కుడి వైపు < కె && testEle.get ( కుడి వైపు ) > testEle.get ( ఎక్కువ ) ) {
ఎక్కువ = కుడివైపు;
}
ఉంటే ( ఎక్కువ ! = నేను ) {
సేకరణలు.స్వాప్ ( testsEle, i, గ్రేటర్ ) ;
పోగుచేయు ( testsEle, k, గ్రేటర్ ) ;
}
}
}
పై కోడ్ యొక్క వివరణ:
- మొదట, జాబితా ' పరీక్షలు ''లో డమ్మీ డేటా మూలకాలతో ప్రారంభించబడింది ప్రధాన () ” పద్ధతి మరియు కన్సోల్‌లో ముద్రించబడింది.
- తర్వాత, “testEle” జాబితా “maxHeapify()” ఫంక్షన్‌కి పంపబడుతుంది, ఆపై తిరిగి వచ్చిన జాబితా కన్సోల్‌లో ప్రదర్శించబడుతుంది.
- అప్పుడు, ' maxHeapify() ” పద్ధతి ప్రారంభించబడింది మరియు అందించిన జాబితా పరిమాణం “ని ఉపయోగించడం ద్వారా తిరిగి పొందబడుతుంది పరిమాణం () ” పద్ధతి.
- తరువాత, 'ని ఉపయోగించండి కోసం ” కుప్ప నిర్మాణాన్ని సెట్ చేయడానికి మరియు ప్రతి నోడ్ యొక్క స్థానాన్ని లెక్కించడానికి లూప్ చేయండి.
- ఇప్పుడు, 'ని ఉపయోగించండి హెపిఫై() 'పద్ధతి మరియు 'ఎగువ', 'ఎడమ' మరియు 'కుడి' నోడ్‌ల కోసం వరుసగా 'గ్రేటర్', 'లెఫ్ట్‌సైడ్' మరియు 'రైట్‌సైడ్' వేరియబుల్స్‌కు విలువలను కేటాయించడం ద్వారా స్థానాన్ని సెట్ చేయండి.
- ఆ తర్వాత, బహుళ 'ని ఉపయోగించండి ఉంటే తనిఖీ చేయడానికి షరతులతో కూడిన ప్రకటనలు ' ఎడమ వైపు 'నోడ్' కంటే పెద్దది కుడి వైపు ” నోడ్ మరియు వైస్ వెర్సా. చివరికి, పెద్ద విలువ ''లో నిల్వ చేయబడుతుంది. ఎక్కువ ' నోడ్.
- చివరగా, కొత్త ' ఎక్కువ 'నోడ్ విలువ ఇప్పటికే నిల్వ చేయబడిన విలువతో తనిఖీ చేయబడింది' ఎక్కువ ” నోడ్ వేరియబుల్. ఇంకా ' మార్పిడి() 'లో అతిపెద్ద విలువను సెట్ చేయడానికి ఫంక్షన్ తదనుగుణంగా పనిచేస్తుంది ఎక్కువ ” వేరియబుల్.
అమలు దశ ముగిసిన తర్వాత:
స్నాప్‌షాట్ 'ని ఉపయోగించి గరిష్ట కుప్ప ఉత్పత్తి చేయబడిందని చూపిస్తుంది maxHeapify() ” జావాలో పద్ధతి.
విధానం 2: “Collections.reverseOrder()” పద్ధతిని ఉపయోగించండి
ది ' Collections.reverseOrder() 'పద్ధతి'ని రూపొందించడానికి సరళమైన మరియు సంక్షిప్త పద్ధతిని అందిస్తుంది గరిష్ట కుప్ప ” సేకరణను రివర్స్ క్రమంలో క్రమబద్ధీకరించడం ద్వారా. ఇది కోడ్‌ని మళ్లీ ఉపయోగించడానికి అనుమతిస్తుంది మరియు కస్టమ్‌ని అమలు చేయవలసిన అవసరాన్ని నివారిస్తుంది ' పోగుచేయు 'లాజిక్, దిగువ కోడ్ స్నిప్పెట్‌లో చూపిన విధంగా:
java.util.ArrayList దిగుమతి;java.util.Collections దిగుమతి;
java.util.Listని దిగుమతి చేయండి;
పబ్లిక్ క్లాస్ రివర్స్ ఆర్డర్ ఉదాహరణ {
పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) // ప్రధాన సృష్టి ( ) పద్ధతి
{
జాబితా < పూర్ణ సంఖ్య > testsEle = కొత్త అర్రేలిస్ట్ <> ( ) ;
testEle.add ( 5 ) ;
testEle.add ( 38 ) ;
testEle.add ( 98 ) ;
testEle.add ( 26 ) ;
testEle.add ( 1 ) ;
testEle.add ( 73 ) ;
System.out.println ( 'అసలు జాబితా:' + testsEle ) ;
సేకరణలు.sort ( testsEle, Collections.reverseOrder ( ) ) ;
System.out.println ( 'మాక్స్ హీప్ ఉత్పత్తి చేయబడింది:' + testsEle ) ;
}
}
పై కోడ్ యొక్క వివరణ:
- మొదట, దిగుమతి చేసుకోండి ' అర్రేలిస్ట్ ',' సేకరణలు 'మరియు' జాబితా ” జావా ఫైల్‌లోని యుటిలిటీస్.
- ఆపై, 'ని సృష్టించండి జాబితా ' అనే ' పరీక్షలు ” మరియు జాబితాలో నకిలీ మూలకాలను చొప్పించండి.
- తరువాత, ' క్రమబద్ధీకరించు() డేటా మూలకాలను ఆరోహణ క్రమంలో క్రమబద్ధీకరించడానికి మరియు జాబితాను పరామితిగా పాస్ చేయడానికి 'పద్ధతి ఉపయోగించబడుతుంది' Collections.reverseOrder() ” పద్ధతి. ఇది '' యొక్క క్రమబద్ధీకరణను చేస్తుంది పరీక్షలు ” జాబితా రివర్స్ క్రమంలో.
అమలు దశ ముగిసిన తర్వాత:
'Collections.reverseOrder()' పద్ధతిని ఉపయోగించి 'Max Heap' ఉత్పత్తి చేయబడిందని మరియు క్రమబద్ధీకరించబడిందని స్నాప్‌షాట్ చూపిస్తుంది.
ముగింపు
సృష్టించడం ద్వారా ' గరిష్ట కుప్ప ”, వినియోగదారులు “maxHeapify()” మరియు “Collections.reverseOrder()” పద్ధతులను ఉపయోగించవచ్చు. వారు గరిష్ట మూలకానికి శీఘ్ర ప్రాప్యతను మరియు క్రమబద్ధీకరించబడిన క్రమం యొక్క సమర్థవంతమైన నిర్వహణను అనుమతించే విధంగా మూలకాల సేకరణను నిర్వహిస్తారు. ఇది కేవలం నిర్దిష్ట అవసరాలు మరియు కుప్ప సృష్టి ప్రక్రియపై అవసరమైన నియంత్రణ స్థాయిపై ఆధారపడి ఉంటుంది.