జావాలో బైనరీ కుప్పను ఎలా అమలు చేయాలో అర్థం చేసుకోండి

ఈ వ్యాసం మీకు కుప్ప క్రమబద్ధీకరణ యొక్క పూర్తి అవలోకనాన్ని ఇస్తుంది మరియు తరువాత మేము జావాలో బైనరీ హీప్‌ను అమలు చేయడం నేర్చుకుంటాము.

ఈ వ్యాసం యొక్క ఎజెండా ఇక్కడ ఉంది:

1. కుప్ప క్రమబద్ధీకరణ అంటే ఏమిటి?
2. మాక్స్ హీప్
3. కనిష్ట కుప్ప
4. జావాలో కుప్ప అమలు
   • రేఖాచిత్రం
   • కోడ్

ప్రారంభిద్దాం!

కుప్ప క్రమబద్ధీకరణ అంటే ఏమిటి?

కుప్ప ప్రాథమికంగా చెట్టు ఆధారిత డేటా నిర్మాణం. దీనికి నోడ్స్ ఉన్నాయి. నోడ్ కొన్ని అంశాలను కలిగి ఉంటుంది. ప్రతి నోడ్‌లో ఒక మూలకం ఉంటుంది.

నోడ్స్ పిల్లలు కలిగి ఉండవచ్చు. పిల్లలు లేకపోతే, దానిని ఆకు అంటారు.

అనుసరించాల్సిన రెండు నియమాలు ఉన్నాయి:

• ప్రతి నోడ్ యొక్క విలువ దాని పిల్లలలో నిల్వ చేయబడిన అన్ని విలువలకు తక్కువ లేదా సమానంగా ఉండాలి.
• ఇది సాధ్యమైనంత తక్కువ ఎత్తును కలిగి ఉంది.

కుప్పలు తీయడంలో చాలా సమర్థవంతంగా పనిచేస్తాయికనీసం లేదా గొప్ప మూలకం.

ఇప్పుడే నిమిషం కుప్పకు వెళ్దాం!

కనిష్ట కుప్ప

మిన్ హీప్ అనేది పూర్తి బైనరీ చెట్టు, దీనిలో మూల మూలకం యొక్క విలువ పిల్లల మూలకం కంటే తక్కువ లేదా సమానంగా ఉంటుంది.

నిమిషం కుప్ప యొక్క ప్రాతినిధ్యం

అర్ [(i-1) / 2]: ఇది పేరెంట్ నోడ్‌ను తిరిగి ఇస్తుంది.

డెఫ్ __ఇనిట్ __ (స్వీయ):

అర [[2 * i) + 1]: ఇది ఎడమ పిల్లల నోడ్‌ను తిరిగి ఇస్తుంది.

అర [[2 * i) + 2]: ఇది సరైన పిల్లల నోడ్‌ను అందిస్తుంది.

మిన్ హీప్ యొక్క కొన్ని పద్ధతులు ఉన్నాయి:

• చొప్పించు (): చెట్టు చివర కొత్త కీ జోడించబడింది. ఒకవేళ క్రొత్త కీ పెద్దది అయితే పేరెంట్, అప్పుడు ఏమీ చేయవలసిన అవసరం లేదు, లేకపోతే, కుప్ప ఆస్తిని ఏర్పాటు చేయడానికి మనం ప్రయాణించాలి.
• getMin (): ఈ పద్ధతులు మూల మూలకాన్ని తిరిగి ఇవ్వడానికి సహాయపడతాయి.
• ఎక్స్‌ట్రాక్ట్మిన్ (): ఈ పద్ధతి కనిష్టాన్ని అందిస్తుందిమూలకం.

ఇప్పుడు మాక్స్ కుప్పకు వెళుతోంది.

గరిష్ట కుప్ప

మాక్స్ హీప్ అనేది పూర్తి బైనరీ చెట్టు, దీనిలో మూల మూలకం యొక్క విలువ పిల్లల మూలకం కంటే ఎక్కువ లేదా సమానంగా ఉంటుంది.

మాక్స్ కుప్ప అనేక పద్ధతులను కలిగి ఉంటుంది!

• చొప్పించు (): ఇది కుప్పలో ఒక మూలకాన్ని చొప్పిస్తుంది.
• తొలగించు () : ఇది కుప్ప నుండి ఒక మూలకాన్ని తొలగిస్తుంది.
• ఫైండ్‌మాక్స్ (): ఇది కుప్ప నుండి గరిష్ట మూలకాన్ని కనుగొంటుంది.
• printHeap (): ఇది కుప్ప యొక్క కంటెంట్ను ముద్రిస్తుంది

ఇప్పుడు ఒక రేఖాచిత్రం మరియు తరువాత జావా ద్వారా కుప్ప అమలును మీకు చూపిస్తానుకోడ్.

జావాలో కుప్ప అమలు

రేఖాచిత్రం:

పై రేఖాచిత్రం జావాలోని బైనరీ కుప్పను చూపిస్తుంది. రెండు కుప్పలు ఉన్నాయని మీరు తెలుసుకున్నట్లు: మిన్ హీప్ మరియు మాక్స్ హీప్, ఇక్కడ ఒక రేఖాచిత్రం ఉంది:

ఇప్పుడు, మా తదుపరి విభాగానికి వెళుతున్నప్పుడు, జావాలో బైనరీ కుప్పను ఎలా అమలు చేయాలో చూద్దాం.

కోడ్:

పబ్లిక్ క్లాస్ బైనరీహీప్ {ప్రైవేట్ స్టాటిక్ ఫైనల్ పూర్ణాంకం d = 2 ప్రైవేట్ పూర్ణాంకం [] కుప్ప ప్రైవేట్ ఇంటెంట్ హీప్‌సైజ్ / ** * ఇది మా కుప్పను డిఫాల్ట్ పరిమాణంతో ప్రారంభిస్తుంది. * / పబ్లిక్ బైనరీహీప్ (పూర్ణాంక సామర్థ్యం) {heapSize = 0 heap = new int [సామర్థ్యం + 1] శ్రేణులు.ఫిల్ (కుప్ప, -1)} / ** * కుప్ప ఖాళీగా ఉందో లేదో ఇది తనిఖీ చేస్తుంది * సంక్లిష్టత: O ( 1) * / పబ్లిక్ బూలియన్ isEmpty () {return heapSize == 0} / ** * ఇది కుప్ప నిండి ఉందో లేదో తనిఖీ చేస్తుంది * సంక్లిష్టత: O (1) * / పబ్లిక్ బూలియన్ isFull () {return heapSize == heap .length} private int parent (int i) {return (i-1) / d} private int kthChild (int i, int k) {return d * i + k} / ** * ఇది కొత్త మూలకాన్ని కుప్పలోకి చొప్పిస్తుంది * సంక్లిష్టత: ఓ (లాగ్ ఎన్) * చెత్త దృష్టాంతంలో, మేము రూట్ వరకు ప్రయాణించాల్సిన అవసరం ఉంది * / పబ్లిక్ శూన్య ఇన్సర్ట్ (Int x) {if (isFull ()) కొత్త NoSuchElementException ('కుప్ప నిండింది, చొప్పించడానికి స్థలం లేదు క్రొత్త మూలకం ') కుప్ప [heapSize ++] = x heapifyUp (heapSize-1)} / ** * ఇది సూచిక x వద్ద మూలకాన్ని తొలగిస్తుంది * సంక్లిష్టత: O (లాగ్ N) * * / పబ్లిక్ పూర్ణాంకం తొలగించు (int x) {if (isEmpty ()) కొత్త NoSuchElementException ను విసిరేయండి ('కుప్ప ఖాళీగా ఉంది, తొలగించడానికి మూలకం లేదు') int key = heap [x] heap [x] = heap [heapSize -1] heapSize-- heapifyDown (x) retu rn key} / ** * ఈ పద్ధతి ఒక మూలకాన్ని చొప్పించేటప్పుడు కుప్ప ఆస్తిని నిర్వహించడానికి ఉపయోగించబడుతుంది. * * / private void heapifyUp (int i) {int temp = heap [i] అయితే (i> 0 && temp> కుప్ప [పేరెంట్ (i)]) {కుప్ప [i] = కుప్ప [పేరెంట్ (i)] i = పేరెంట్ (i)} కుప్ప [i] = టెంప్} / ** * ఈ పద్ధతి ఒక మూలకాన్ని తొలగించేటప్పుడు కుప్ప ఆస్తిని నిర్వహించడానికి ఉపయోగించబడుతుంది. * * / ప్రైవేట్ శూన్యమైన heapifyDown (int i) {int child int temp = heap [i] అయితే (kthChild (i, 1)కుప్ప [rightChild]? leftChild: rightChild} / ** * ఈ పద్ధతి కుప్ప యొక్క అన్ని మూలకాలను ముద్రించడానికి ఉపయోగించబడుతుంది * * / పబ్లిక్ శూన్యమైన printHeap () {System.out.print ('nHeap =') (int i = 0 i
దీనితో, మేము జావాలోని బైనరీ హీప్ పై ఈ వ్యాసం చివరకి వచ్చాము. చూడండి    ప్రపంచవ్యాప్తంగా విస్తరించి ఉన్న 250,000 మందికి పైగా సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించబడింది. ఈ కోర్సు మీకు జావా ప్రోగ్రామింగ్‌లోకి రావడానికి మరియు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది. 
 మాకు ప్రశ్న ఉందా? దయచేసి ఈ “జావా అర్రేలిస్ట్” బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.