జావాలో చొప్పించడం క్రమబద్ధీకరించు

శ్రేణులను క్రమబద్ధీకరించడం అనేది జావా అనుభవశూన్యుడు ఎలా చేయాలో తెలుసుకోవలసిన అత్యంత సాధారణ కార్యకలాపాలలో ఒకటి. శ్రేణులు ఎల్లప్పుడూ డేటాను అమర్చడానికి అత్యంత అనుకూలమైన మార్గం కానప్పటికీ మరియు ఇది చిన్న సంఖ్యలకు ఎక్కువగా వర్తిస్తుంది, శ్రేణి సార్టింగ్ వెనుక ఉన్న భావన సంక్లిష్ట సాఫ్ట్‌వేర్ మరియు డేటా సైన్స్‌లో టన్నుల కొద్దీ అప్లికేషన్‌లను కలిగి ఉంది. ఈ పోస్ట్‌లో, చొప్పించే క్రమబద్ధీకరణ అంటే ఏమిటో మేము నిశితంగా పరిశీలిస్తాము. ఈ భావనను పూర్తిగా అర్థం చేసుకోవడంలో మీకు సహాయపడటానికి మేము కొన్ని ఉదాహరణలు మరియు అభ్యాస సమస్యలను చేర్చాము.

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

ప్రాథమికంగా, చొప్పించే క్రమబద్ధీకరణ అనేది డెవలపర్లు చిన్న సంఖ్యల స్ట్రింగ్‌లను నిర్వహించడానికి ఉపయోగించే అల్గారిథమ్. ఇది అన్ని విలువలను రెండు స్టాక్‌లుగా విభజిస్తుంది - క్రమబద్ధీకరించబడినది మరియు క్రమబద్ధీకరించనిది. "క్రమబద్ధీకరించబడని" స్టాక్‌లోని సంఖ్యలు ఒక్కొక్కటిగా ఎంపిక చేయబడతాయి మరియు సరైన క్రమంలో ఉంచబడతాయి. ఇన్‌పుట్ మరియు చొప్పించే క్రమబద్ధీకరణ యొక్క అవుట్‌పుట్‌ను నిశితంగా పరిశీలిద్దాం:

• ఇన్‌పుట్: క్రమబద్ధీకరించని సంఖ్యా మూలకాలతో కూడిన శ్రేణి 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. ఆర్డర్ చేసిన క్రమాన్ని సృష్టించడానికి చిన్నదాని కంటే పెద్ద విలువను ఒక స్థానాన్ని మార్చుకోండి. nkeysort()దశ 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

while లూప్‌లోని రెండు షరతులు నిజం అయిన వెంటనే, శ్రేణి యొక్క కీ విలువ సూచికకు సమానంగా ఉంటుంది 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;

అర్రేలిస్ట్‌ని క్రమబద్ధీకరిస్తోంది

చొప్పించే క్రమబద్ధీకరణ వెనుక ఉన్న గణితాన్ని అర్థం చేసుకోవడం ముఖ్యం అయినప్పటికీ, నిజ జీవిత సాఫ్ట్‌వేర్ డెవలప్‌మెంట్ విషయానికి వస్తే, మీరు ఆదిమ శ్రేణులలోని సీక్వెన్స్‌ల కంటే చాలా ఎక్కువగా అర్రేలిస్ట్‌లను క్రమబద్ధీకరిస్తారు. అర్రేలిస్ట్‌ను క్రమబద్ధీకరించడానికి ఇక్కడ దశల వారీ గైడ్ ఉంది:

1. Elementసేకరణకు చెందిన అంశాల కోసం కొత్త తరగతిని సృష్టించండి .

   
   public class Element {
       private int id;
   
       public Element(int id) {
           this.id = id;
       }
   

2. సేకరణలో, ఒక 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;
       }
   }
   

3. అల్గారిథమ్‌ని వర్తింపజేయండి మరియు వస్తువులను 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);
       }
   }
   

4. 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);
   

5. ఇప్పుడు క్రమబద్ధీకరించే సమయం వచ్చింది:

   
   // 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() + ", "));
   

6. ఇప్పుడు మనం పొరపాట్లు చేయలేదని నిర్ధారించుకోవడానికి ఇన్‌పుట్ మరియు అవుట్‌పుట్‌ని సరిపోల్చండి. మేము ఉదాహరణగా ఉపయోగించిన స్ట్రింగ్ యొక్క పోలిక ఇక్కడ ఉంది.

   
   4, 2, 6, 7, 0, 5, 9, 1, 8, 3,
   0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
   

చొప్పించడం క్రమబద్ధీకరణ ప్రాక్టీస్ సమస్యలు

ఇప్పుడు మీరు ఈ క్రమబద్ధీకరణ అల్గారిథమ్‌ని కలిగి ఉన్నారు, మీ సైద్ధాంతిక మరియు ఆచరణాత్మక నైపుణ్యాలను పరీక్షించాల్సిన సమయం ఆసన్నమైంది. థియరీ క్విజ్ #1 మీకు అర్రే [1, 4, 6, 8] ఇవ్వబడింది మరియు దానికి కొత్త మూలకం n = 7 జోడిస్తోంది. క్రమబద్ధీకరించబడిన సంఖ్యల క్రమాన్ని పొందడానికి మీరు ఎన్ని పోలికలను చేయాలి? శ్రేణిలో సూచిక n యొక్క తుది విలువను సూచించండి. థియరీ క్విజ్ #2 ఉద్యోగ ఇంటర్వ్యూలో, క్రమబద్ధీకరించడం అసమర్థమైన పద్ధతి అని నిరూపించమని టీమ్ లీడ్ మిమ్మల్ని అడుగుతుంది. [0, 3, 6, 8, 9] యొక్క సంఖ్యా స్ట్రింగ్ ఇచ్చినట్లయితే, సార్టింగ్ కోసం అవసరమైన రన్నింగ్ టైమ్‌ని పెంచడానికి మీ ఇన్‌పుట్ సీక్వెన్స్ యొక్క క్రమం ఎలా ఉండాలి? ప్రాక్టీస్ సమస్య జావా కోసం చొప్పించే క్రమాన్ని ఉపయోగించి [0, 1, 4, 5, 2, 3, 7, 9, 8] శ్రేణిని ఆరోహణ క్రమంలో క్రమబద్ధీకరించండి.

ముగింపు

చొప్పించే క్రమాన్ని గ్రహించడంలో అతిపెద్ద సవాలు ప్రక్రియ ఎలా పనిచేస్తుందో అర్థం చేసుకోవడం. మీరు దాన్ని హ్యాంగ్ చేసిన తర్వాత, టెంప్లేట్‌ను కోడ్‌గా మార్చడం కేక్ ముక్క. మీరు ప్రాక్టీస్ చేసినంత కాలం మరియు సంబంధిత ప్రాక్టీస్ సమస్యలను కాలక్రమేణా తిరిగి సందర్శించినంత కాలం, మీరు మీ చొప్పించే క్రమబద్ధీకరణ వేగాన్ని వేగంగా మెరుగుపరుస్తారు.