జావాలో 2డి అర్రేని ఎలా క్రమబద్ధీకరించాలి

Javalo 2di Arreni Ela Kramabad Dhikarincali



రెండు డైమెన్షనల్ లేదా 2D శ్రేణి అనేది నిలువు వరుసలు మరియు అడ్డు వరుసల సమాహారం. ప్రోగ్రామర్లు యాదృచ్ఛికంగా 2D శ్రేణి మూలకాలను లేదా ప్రతి సెల్‌ను వారి సూచికలను ఉపయోగించడం ద్వారా వ్యక్తిగతంగా యాక్సెస్ చేయవచ్చు. క్రమబద్ధీకరణ సహాయంతో, శ్రేణి మూలకాలు ఆరోహణ లేదా అవరోహణ క్రమంలో అవసరాలకు అనుగుణంగా అమర్చబడతాయి. మరింత ప్రత్యేకంగా, జావా ' Array.sort() ” ప్రోగ్రామ్‌లోని 2D శ్రేణి యొక్క మూలకాల కోసం ఉపయోగించవచ్చు.

ఈ ట్యుటోరియల్ జావాలో 2D శ్రేణులను ఎలా క్రమబద్ధీకరించాలో చర్చిస్తుంది.

జావాలో 2D అర్రేని ఎలా క్రమబద్ధీకరించాలి?

జావాలో, మీరు దీన్ని ఉపయోగించి 2D శ్రేణిని క్రమబద్ధీకరించవచ్చు:







మేము ఇప్పుడు పేర్కొన్న ప్రతి పద్ధతులను ఒక్కొక్కటిగా చర్చిస్తాము.



విధానం 1: జావాలో 2D అర్రేని వరుసల వారీగా క్రమబద్ధీకరించడం

వరుసల వారీగా క్రమబద్ధీకరించడంలో, మీరు “ని ఉపయోగించవచ్చు Array.sort() శ్రేణి మూలకాలను క్రమబద్ధీకరించే పద్ధతి. ఇది నిర్దిష్ట అడ్డు వరుసలోని ప్రతి మూలకాన్ని పునరావృతం చేస్తుంది మరియు ప్రస్తుత మూలకం తదుపరి దాని కంటే ఎక్కువగా ఉన్నప్పుడు పూర్ణాంకాలను మార్చుకుంటుంది.



అమలు వైపు అర్థం చేసుకోవడానికి ఒక ఉదాహరణను చూద్దాం.





ఉదాహరణ
ఈ ఉదాహరణలో, మొదట మేము స్టాటిక్ పద్ధతిని సృష్టిస్తాము ' rowWiseSorting() ” అని పిలవడం ద్వారా శ్రేణిని ఆరోహణ క్రమంలో క్రమబద్ధీకరించడానికి Arrays.sort() ” అర్రేస్ క్లాస్ యొక్క పద్ధతి మరియు ఆపై శ్రేణి యొక్క క్రమబద్ధీకరించబడిన ఎలిమెంట్‌లను ఉపయోగించి ప్రింట్ చేయండి కోసం ”లూప్‌లు:

స్థిరమైన int rowWiseSorting ( int అరె [ ] [ ] ) {
కోసం ( int i = 0 ; i < అరె. పొడవు ; i ++ ) {
శ్రేణులు. క్రమబద్ధీకరించు ( అరె [ i ] ) ;
}
కోసం ( int i = 0 ; i < అరె. పొడవు ; i ++ ) {
కోసం ( int జె = 0 ; జె < అరె [ i ] . పొడవు ; జె ++ ) {
వ్యవస్థ. బయటకు . ముద్రణ ( అరె [ i ] [ జె ] + '' ) ;
}
వ్యవస్థ. బయటకు . println ( ) ;
}
తిరిగి 0 ;
}

ఇక్కడ, మనకు '' అనే 2D శ్రేణి ఉంది. అరె ” 3×3 మాతృక రూపం (మూడు అడ్డు వరుసలు మరియు మూడు నిలువు వరుసలు). ఇప్పుడు, సృష్టించిన శ్రేణి యొక్క వరుసలను క్రమబద్ధీకరించడానికి, మేము పద్ధతిని పిలుస్తాము ' rowWiseSorting() ప్రధాన() పద్ధతిలో శ్రేణిని ఆర్గ్యుమెంట్‌గా పాస్ చేయడం ద్వారా:



ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
int అరె [ ] [ ] = కొత్త int [ ] [ ] {
{ 12 , 14 , 4 } ,
{ 14 , 23 , ఇరవై } ,
{ 28 , 25 , 8 } ,
{ పదకొండు , 5 , 1 } } ;
rowWiseSorting ( అరె ) ;
}
}

మీరు చూడగలిగినట్లుగా, మేము మా శ్రేణిని ఆరోహణ క్రమంలో క్రమబద్ధీకరించాము:

జావాలో కాలమ్ వారీగా క్రమబద్ధీకరించడాన్ని ప్రయత్నించాలనుకుంటున్నారా? క్రింది విభాగాన్ని పరిశీలించండి.

విధానం 2: జావాలో 2D అర్రేని నిలువు వరుసల వారీగా క్రమబద్ధీకరించడం

జావాలో 2D శ్రేణిని నిలువు వరుసల వారీగా క్రమబద్ధీకరించడానికి, కాల్ చేయండి Arrays.sort() 'ఒక' తో పద్ధతి కంపారిటర్ ఇంటర్ఫేస్ ”. కంపారిటర్ ఇంటర్‌ఫేస్ ఒక “ని నిర్వచిస్తుంది సరిపోల్చండి() ” రెండు పారామితులను అంగీకరించి, ఆపై వాటిని ఒకదానితో ఒకటి పోల్చి చూసే పద్ధతి. పాస్ చేసిన పారామితులు సమానంగా ఉంటే, అది సున్నాని అందిస్తుంది. 1వ పరామితి 2వ పరామితి కంటే ఎక్కువగా ఉంటే, అది సానుకూల విలువను అందిస్తుంది. లేకపోతే, ప్రతికూల విలువ తిరిగి ఇవ్వబడుతుంది.

ఉదాహరణ
ఈ ఉదాహరణలో, మేము '' అనే పద్ధతిని సృష్టిస్తాము. కాలమ్‌వారీగా క్రమబద్ధీకరించడం() 'రెండు ఆర్గ్యుమెంట్‌లతో, 2D శ్రేణి' అర్[][] ” మరియు “ అనే పేరు గల నిలువు వరుస సంఖ్య పర్యావలోకనం ”. అప్పుడు, కాల్ చేయండి ' Arrays.sort() 'తో పద్ధతి' కంపారిటర్ ఇంటర్ఫేస్ ” నిలువు వరుస విలువలను పోల్చడానికి. చివరగా, మేము ''ని ఉపయోగించి క్రమబద్ధీకరించబడిన శ్రేణి నిలువు వరుస యొక్క విలువలను ముద్రిస్తాము. కోసం ”లూప్‌లు:

స్థిరమైన శూన్యం columnWiseSorting ( int అరె [ ] [ ] , int పర్యావలోకనం ) {
శ్రేణులు. క్రమబద్ధీకరించు ( అరె , కొత్త కంపారిటర్ < int [ ] > ( ) {
ప్రజా int సరిపోల్చండి ( int [ ] frst , int [ ] scnd ) {
ఉంటే ( frst [ పర్యావలోకనం - 1 ] > scnd [ పర్యావలోకనం - 1 ] ) {
తిరిగి 1 ;
}
లేకపోతే తిరిగి - 1 ;
}
} ) ;
}
కోసం ( int i = 0 ; i < అరె. పొడవు ; i ++ ) {
కోసం ( int జె = 0 ; జె < అరె [ i ] . పొడవు ; జె ++ ) {
వ్యవస్థ. బయటకు . ముద్రణ ( అరె [ i ] [ జె ] + '' ) ;
}
వ్యవస్థ. బయటకు . println ( ) ;
}

మేము ఇప్పటికే సృష్టించిన శ్రేణిని ఉపయోగిస్తాము ' అరె 'మరియు దానిని 'కి పంపండి కాలమ్‌వారీగా క్రమబద్ధీకరించడం() 'మొదటి పరామితిగా మరియు' 1 'రెండవ పరామితిగా:

columnWiseSorting ( అరె , 1 ) ;

పైన ఇచ్చిన ప్రోగ్రామ్ యొక్క అమలు మా 2D శ్రేణి యొక్క మొదటి నిలువు వరుసను క్రమబద్ధీకరిస్తుంది:

మేము జావాలో 2D శ్రేణిని క్రమబద్ధీకరించడానికి అవసరమైన మొత్తం సమాచారాన్ని కంపైల్ చేస్తాము.

ముగింపు

జావాలో, 2D శ్రేణిని అవసరాలకు అనుగుణంగా వరుసల వారీగా లేదా నిలువు వరుసల వారీగా క్రమబద్ధీకరించవచ్చు. వరుసల వారీగా క్రమబద్ధీకరించడానికి, Array.sort() పద్ధతి మాత్రమే ఉపయోగించబడుతుంది; అయితే, కాలమ్ వారీగా సార్టింగ్‌లో, Array.sort() పద్ధతిని కంపారేటర్ ఇంటర్‌ఫేస్‌తో పిలుస్తారు. అడ్డు వరుసల వారీగా క్రమబద్ధీకరించడం కోసం, Array.sort() పద్ధతికి పరామితి పాస్ చేయబడదు, అయితే, నిలువు వరుసల వారీగా క్రమబద్ధీకరించాల్సిన పద్ధతిలో, క్రమబద్ధీకరించాల్సిన నిలువు వరుసల సంఖ్య పారామీటర్‌గా పేర్కొనబడింది. ఈ ట్యుటోరియల్ ఉదాహరణలతో జావాలో 2D శ్రేణిని క్రమబద్ధీకరించే పద్ధతులను చర్చించింది.