శ్రేణులను క్రమబద్ధీకరించడం అనేది జావా అనుభవశూన్యుడు ఎలా చేయాలో తెలుసుకోవలసిన అత్యంత సాధారణ కార్యకలాపాలలో ఒకటి. శ్రేణులు ఎల్లప్పుడూ డేటాను అమర్చడానికి అత్యంత అనుకూలమైన మార్గం కానప్పటికీ మరియు ఇది చిన్న సంఖ్యలకు ఎక్కువగా వర్తిస్తుంది, శ్రేణి సార్టింగ్ వెనుక ఉన్న భావన సంక్లిష్ట సాఫ్ట్వేర్ మరియు డేటా సైన్స్లో టన్నుల కొద్దీ అప్లికేషన్లను కలిగి ఉంది. ఈ పోస్ట్లో, చొప్పించే క్రమబద్ధీకరణ అంటే ఏమిటో మేము నిశితంగా పరిశీలిస్తాము. ఈ భావనను పూర్తిగా అర్థం చేసుకోవడంలో మీకు సహాయపడటానికి మేము కొన్ని ఉదాహరణలు మరియు అభ్యాస సమస్యలను చేర్చాము.
ఇన్పుట్ మరియు చొప్పించే క్రమబద్ధీకరణ యొక్క అవుట్పుట్ను నిశితంగా పరిశీలిద్దాం:
చొప్పించే క్రమబద్ధీకరణ అంటే ఏమిటి?
ప్రాథమికంగా, చొప్పించే క్రమబద్ధీకరణ అనేది డెవలపర్లు చిన్న సంఖ్యల స్ట్రింగ్లను నిర్వహించడానికి ఉపయోగించే అల్గారిథమ్. ఇది అన్ని విలువలను రెండు స్టాక్లుగా విభజిస్తుంది - క్రమబద్ధీకరించబడినది మరియు క్రమబద్ధీకరించనిది. "క్రమబద్ధీకరించబడని" స్టాక్లోని సంఖ్యలు ఒక్కొక్కటిగా ఎంపిక చేయబడతాయి మరియు సరైన క్రమంలో ఉంచబడతాయి.
- ఇన్పుట్: క్రమబద్ధీకరించని సంఖ్యా మూలకాలతో కూడిన శ్రేణి A: A[0,1, n, n-2...].
- అవుట్పుట్: ఒకే సంఖ్యలను కలిగి ఉన్న శ్రేణి కానీ పూర్తిగా క్రమబద్ధీకరించబడింది. దీనిని సాధారణంగా B: B[0]B[1]...B[n-1]గా సూచిస్తారు.
- సంఖ్యా క్రమబద్ధీకరణ (పెరుగుతున్న క్రమం): [1, 2, 3, 4, 5]
- సంఖ్యా క్రమబద్ధీకరణ (తగ్గుతున్న క్రమం): [5, 4, 3, 2, 1]
- అక్షర క్రమబద్ధీకరణ: [a, b, c, d]
చొప్పించే క్రమబద్ధీకరణ సిద్ధాంతాన్ని అర్థం చేసుకోవడం
చొప్పించే క్రమబద్ధీకరణ వెనుక ఉన్న కోడ్ను అన్వేషించే ముందు, సాంకేతికత లేని భాషను ఉపయోగించి అల్గారిథమ్ను విచ్ఛిన్నం చేద్దాం. మేము ఆరోహణ క్రమంలో క్రమబద్ధీకరించడానికి కోడ్ను చూపుతాము కాబట్టి, ఈ పోస్ట్లో దశలవారీగా అల్గారిథమ్ను వివరించడం అర్ధమే. దశ 1. ఒక సంఖ్యా విలువ సాధారణంగా 10 కంటే తక్కువగా ఉంటుందిarr[1]
మరియు arr[n]
వాటి మధ్య పునరావృతం చేయడం . దశ 2. మీరు ఎంచుకున్న మూలకాన్ని (అని పిలుస్తారు ) పద్ధతిని ఉపయోగించి సీక్వెన్స్లోని మునుపటి సంఖ్యతో సరిపోల్చండి . దశ 3. అన్ని మూలకాలు వాటి వారసుల కంటే చిన్నవి అయితే, మీరు పెద్ద విలువను కనుగొనే వరకు పోలికను పునరావృతం చేయండి. దశ 4. ఆర్డర్ చేసిన క్రమాన్ని సృష్టించడానికి చిన్నదాని కంటే పెద్ద విలువను ఒక స్థానాన్ని మార్చుకోండి. n
key
sort()
దశ 5. మీరు క్రమబద్ధీకరించబడిన అక్షరాల స్ట్రింగ్ను పొందే వరకు ప్రక్రియను పునరావృతం చేయండి
ఆదిమ శ్రేణులను క్రమబద్ధీకరించడం
అల్గోరిథం అత్యంత సరళమైన జావా కార్యకలాపాలలో ఒకటి కాబట్టి, పూర్తి ప్రారంభకులకు కూడా దీన్ని అమలు చేయడంలో పెద్దగా ఇబ్బంది ఉండదు. శ్రేణిని క్రమబద్ధీకరించడానికి ఇక్కడ దశల వారీ గైడ్ ఉంది1. క్రమబద్ధీకరణ కోసం శ్రేణిని ప్రకటించండి
ప్రారంభించడానికి, మేము జావాను ఉపయోగించి తర్వాత ప్రదర్శించే విలువల స్ట్రింగ్ను క్రియేట్ చేద్దాం. చొప్పించే క్రమాన్ని ఉపయోగించడానికి, మీరు శ్రేణిని సృష్టించాలి. దాని కోసం, ఉపయోగించండిint[]
int[] arrayA = {10, 14, 20, 30};
2. అల్గోరిథం అమలు చేయడానికి sort_arr ఉపయోగించండి
చొప్పించే క్రమాన్ని అమలు చేయడానికి చాలా సాధారణ మార్గాలలో sort_arr పద్ధతి ఒకటి. ఆచరణలో, ఇది ఇలా కనిపిస్తుంది:
for(int i=0; i< sort_arr.length; ++i){
int j = i;
3. లూప్ మరియు ఇటరేటర్ను సృష్టించండి
చొప్పించే క్రమబద్ధీకరణ అల్గారిథమ్లో లూప్ని ఉపయోగించడం ద్వారా, డెవలపర్లు ప్రతి మూలకం కోసం లాజిక్ను పునరావృతం చేయవలసిన అవసరం లేదు. లూప్లను సృష్టించడం సంక్లిష్టంగా అనిపించినప్పటికీ, ఇది చాలా సులభం - ఇక్కడ ఒక ఉదాహరణ:
for(int i=0; i< sort_arr.length; ++i){
ఇప్పుడు మీరు పని చేసే లూప్ని కలిగి ఉన్నారు, కావలసిన క్రమంలో అన్ని ఎలిమెంట్లను క్రమబద్ధీకరించే ఇటరేటర్ని సృష్టించడానికి ఇది సమయం. ఇప్పటి నుండి, మేము ఇటరేటర్ని ""గా సూచిస్తాము j
.
int j = i;
4. "వేల్ లూప్"ని సృష్టించడం
చొప్పించే క్రమబద్ధీకరణ విషయానికి వస్తే, కొత్త, క్రమబద్ధీకరించబడిన శ్రేణికి "వేళ" లూప్ అవసరం. ఆరోహణ-క్రమం చొప్పింపు క్రమబద్ధీకరణ కోసం దీన్ని సెటప్ చేయడానికి, డెవలపర్ రెండు షరతులకు అనుగుణంగా ఉండాలి:- jకి కేటాయించిన విలువ 0 కంటే ఎక్కువగా ఉండాలి
- కేటాయించిన విలువ సూచిక
j-1
కంటే ఎక్కువగా ఉండాలిj
j
.
5. శ్రేణిని క్రమబద్ధీకరించడం
మీరు while లూప్ని సెటప్ చేసిన తర్వాత, while లూప్లోని ఒకటి లేదా రెండు షరతులు విఫలమయ్యే వరకుj
మరియు j-1
విలువలు మార్చబడతాయి. అదేవిధంగా, ఫర్-లూప్ పరిస్థితులు కూడా విఫలమయ్యే వరకు ఫర్ లూప్లోని ప్రతి విలువకు సార్టింగ్ పునరావృతమవుతుంది. చొప్పించే క్రమబద్ధీకరణ ప్రక్రియ ఆచరణలో ఎలా పనిచేస్తుందో ఇక్కడ ఉంది:
int key = sort_arr[j];
sort_arr[j] = sort_arr[j-1];
sort_arr[j-1] = key;
j = j-1;
అర్రేలిస్ట్ని క్రమబద్ధీకరిస్తోంది
చొప్పించే క్రమబద్ధీకరణ వెనుక ఉన్న గణితాన్ని అర్థం చేసుకోవడం ముఖ్యం అయినప్పటికీ, నిజ జీవిత సాఫ్ట్వేర్ డెవలప్మెంట్ విషయానికి వస్తే, మీరు ఆదిమ శ్రేణులలోని సీక్వెన్స్ల కంటే చాలా ఎక్కువగా అర్రేలిస్ట్లను క్రమబద్ధీకరిస్తారు. అర్రేలిస్ట్ను క్రమబద్ధీకరించడానికి ఇక్కడ దశల వారీ గైడ్ ఉంది:Element
సేకరణకు చెందిన అంశాల కోసం కొత్త తరగతిని సృష్టించండి .public class Element { private int id; public Element(int id) { this.id = id; }
- సేకరణలో, ఒక
compareTo()
పద్ధతి ఉంది - మేము రెండు మూలకాల ఐడిలను పోల్చడానికి దీన్ని ఉపయోగిస్తాము.public int compareTo(Element element) { int res = 0; if (this.id < element.getId()) { res = -1; } if (this.id > element.getId()) { res = 1; } return res; } }
- అల్గారిథమ్ని వర్తింపజేయండి మరియు వస్తువులను
ArrayList
పోల్చడానికి బదులుగా వాటిని క్రమబద్ధీకరించడానికి కొన్ని లూప్లను సృష్టించండి.public static void insertionSortArrayList(List<element> list) { for (int j = 1; j < list.size(); j++) { Element current = list.get(j); int i = j-1; while ((i > -1) && ((list.get(i).compareTo(current)) == 1)) { list.set(i+1, list.get(i)); i--; } list.set(i+1, current); } }
ArrayList
దిగువ చూపిన విధంగా మీరు మరిన్ని అంశాలను కూడా జోడించవచ్చు :List<element> list = new ArrayList<>(); // Create elements w/ IDs 0-24 for (int i = 0; i < 25; i++) { list.add(new Element(i)); } // To use insertion sort, shuffle the values Collections.shuffle(list);
- ఇప్పుడు క్రమబద్ధీకరించే సమయం వచ్చింది:
// This helps print values before sorting list.forEach(e -> System.out.print(e.getId() + ", ")); // Sort the list insertionSortArrayList(list); System.out.println(); // Display a sorted array list.forEach(e -> System.out.print(e.getId() + ", "));
- ఇప్పుడు మనం పొరపాట్లు చేయలేదని నిర్ధారించుకోవడానికి ఇన్పుట్ మరియు అవుట్పుట్ని సరిపోల్చండి. మేము ఉదాహరణగా ఉపయోగించిన స్ట్రింగ్ యొక్క పోలిక ఇక్కడ ఉంది.
4, 2, 6, 7, 0, 5, 9, 1, 8, 3, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
GO TO FULL VERSION