బబుల్ క్రమబద్ధీకరణ జావా

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

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

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

బబుల్ సార్ట్ ఎలా పని చేస్తుంది

మనం పూర్ణాంకాల శ్రేణిని ఆరోహణ క్రమంలో క్రమబద్ధీకరించాలి, అంటే చిన్న సంఖ్య నుండి పెద్ద సంఖ్య వరకు. ముందుగా, మేము మొత్తం శ్రేణిలో వెళుతున్నాము మరియు ప్రతి 2 పొరుగు మూలకాలను సరిపోల్చండి. వారు తప్పు క్రమంలో ఉంటే (ఎడమ పొరుగువారు సరైనదాని కంటే పెద్దది), మేము వాటిని మార్పిడి చేస్తాము. చివరిలో మొదటి పాస్ వద్ద అది అతిపెద్ద మూలకం (మేము ఆరోహణ క్రమంలో క్రమబద్ధీకరించినట్లయితే) కనిపిస్తుంది. మీరు చెప్పవచ్చు, అతిపెద్ద మూలకం "పాప్ అప్". బబుల్ క్రమబద్ధీకరణ అల్గోరిథం పేరుకు అదే కారణం. మేము మొదటి దశ నుండి తదుపరి నుండి చివరి మూలకం వరకు మొదటి దశను పునరావృతం చేస్తాము. మేము తరువాతి నుండి చివరి స్థానంలో రెండవ అతిపెద్ద మూలకాన్ని పొందాము. మరియు అందువలన న. మునుపటి దశలో కనీసం ఒక మార్పిడి జరిగిందో లేదో తనిఖీ చేయడం ద్వారా మేము అల్గారిథమ్‌ను కొద్దిగా మెరుగుపరచవచ్చు. అది కాకపోతే మేము శ్రేణి వెంట మా పరుగును ఆపుతాము.

బబుల్ క్రమబద్ధీకరణ ఉదాహరణ

పూర్ణాంకాల శ్రేణిని క్రమబద్ధీకరించుదాం, ఒకటి, మీరు చిత్రంలో క్రింద చూడవచ్చు. దశ 1: మేము శ్రేణి గుండా వెళుతున్నాము. అల్గోరిథం మొదటి రెండు మూలకాలతో (సూచికలు 0 మరియు 1తో), 8 మరియు 7తో ప్రారంభమవుతుంది మరియు అవి సరైన క్రమంలో ఉన్నాయో లేదో తనిఖీ చేస్తుంది. సహజంగానే, 8 > 7, కాబట్టి మేము వాటిని మార్చుకుంటాము. తరువాత, మేము రెండవ మరియు మూడవ మూలకాలను (సూచికలు 1 మరియు 2) పరిశీలిస్తాము, ఇప్పుడు ఇవి 8 మరియు 1. అదే కారణాల వల్ల, మేము వాటిని మార్చుకుంటాము. మూడవ సారి మేము 8 మరియు 2 మరియు కనీసం 8 మరియు 5 లను పోల్చాము. మేము మొత్తం నాలుగు మార్పిడిని చేసాము: (8, 7), (8, 1), (8, 2) మరియు (8, 5). 8 విలువ, ఈ శ్రేణిలో అతిపెద్దది, జాబితా చివరిలో సరైన స్థానానికి పాప్ అప్ చేయబడింది. బబుల్ క్రమబద్ధీకరణ అల్గోరిథం పని యొక్క మొదటి దశ ఫలితం తదుపరి శ్రేణి: దశ 2. (7,1), (7,2) మరియు (7,5)తో కూడా అదే చేయడం. 7 ఇప్పుడు చివరి స్థానంలో ఉంది మరియు మేము దానిని జాబితా యొక్క "తోక"తో పోల్చాల్సిన అవసరం లేదు, ఇది ఇప్పటికే క్రమబద్ధీకరించబడింది. బబుల్ క్రమబద్ధీకరణ అల్గోరిథం పని చేయడం యొక్క రెండవ దశ ఫలితం తదుపరి శ్రేణి: మీరు చూసినట్లుగా, ఈ శ్రేణి ఇప్పటికే క్రమబద్ధీకరించబడింది. ఏమైనప్పటికీ బబుల్ క్రమబద్ధీకరణ అల్గారిథమ్ కనీసం మరో సారి కొనసాగాలి. దశ3. మేము మరోసారి శ్రేణి గుండా వెళుతున్నాము. ఇక్కడ స్వాప్ చేయడానికి ఏమీ లేదు, కాబట్టి మేము "మెరుగైన" బబుల్ క్రమబద్ధీకరణ అల్గారిథమ్‌ని ఉపయోగిస్తుంటే (మునుపటి దశలో కనీసం ఒక మార్పిడి జరిగిందో లేదో తనిఖీ చేయడంతో) ఈ దశ చివరిది.

బబుల్ క్రమబద్ధీకరణ జావా కోడ్

బబుల్ సార్ట్ జావా రియలైజేషన్

బబుల్ క్రమబద్ధీకరణ కోసం రెండు పద్ధతులను రూపొందిద్దాం. మొదటిది, bubbleSort(int[] myArray) ఒక విమానం. ఇది ప్రతిసారీ శ్రేణి గుండా నడుస్తుంది. రెండవది, optimizedBubbleSort(int myArray[]) అనేది ఇన్నర్ లూప్ ఎటువంటి స్వాప్‌కు కారణం కానట్లయితే అల్గారిథమ్‌ని ఆపడం ద్వారా ఆప్టిమైజ్ చేయబడుతుంది. క్రమబద్ధీకరించేటప్పుడు మీరు ఎన్ని దశలు చేసారో కౌంటర్ మీకు చూపుతుంది. ఇక్కడ మేము బబుల్ సార్ట్ జావా రియలైజేషన్ పొందాము:

import java.util.Arrays;

public class BubbleSortExample {

   //  Plane Bubble sort example

   public static int[] bubbleSort(int[] myArray) {

       int temp = 0;  //  temporary element for swapping
       int counter = 0;  //  element to count quantity of steps

       for (int i = 0; i < myArray.length; i++) {
           counter = i + 1;
           for (int j = 1; j < (myArray.length - i); j++) {

               if (myArray[j - 1] > myArray[j]) {
                   //  swap array’s elements using temporary element
                   temp = myArray[j - 1];
                   myArray[j - 1] = myArray[j];
                   myArray[j] = temp;
               }
           }
       }
       System.out.println("Steps quantity, non optimized = " + counter);
       return myArray;
   }
   //  An optimized version of Java Bubble Sorting

   static int[] optimizedBubbleSort(int myArray[]) {
       int temp;
       boolean swapped;
       int counter = 0;  //  element to count quantity of steps
       for (int i = 0; i < myArray.length - 1; i++) {
           counter = i + 1;
           swapped = false;
           for (int j = 0; j < myArray.length - i - 1; j++) {
               //  counter++;
               if (myArray[j] > myArray[j + 1]) {
                   //  swap arr[j] and arr[j+1]
                   temp = myArray[j];
                   myArray[j] = myArray[j + 1];
                   myArray[j + 1] = temp;
                   swapped = true;

               }
           }  //  counter = i;
           //  If there weren't elements to swap in inner loop, then break
           if (swapped == false) {

               break;

           }
       }
       System.out.println("steps quantity, optimized = " + counter);
       return myArray;
   }


   public static void main(String[] args) {
       int arr[] = {8, 7, 1, 2, 5};
       int arr1[] = {8, 7, 1, 2, 5};

       System.out.println("Array arr Before Bubble Sort");
       //  we use java.util.Arrays toString method to print the array
 System.out.println(Arrays.toString(arr));

       System.out.println("Array arr After Bubble Sort");
       System.out.println(Arrays.toString(bubbleSort(arr)));

       System.out.println("Array arr1 Before Bubble Sort");
       System.out.println(Arrays.toString(arr1));

       System.out.println("Array arr1 After Optimized Bubble Sort");
       System.out.println(Arrays.toString(optimizedBubbleSort(arr1)));
   }
}

బబుల్ క్రమబద్ధీకరణ జావా అల్గోరిథం పని ఫలితం:

Array arr Before Bubble Sort
[8, 7, 1, 2, 5]
Array arr After Bubble Sort
Steps quantity, non optimized = 5
[1, 2, 5, 7, 8]
Array arr1 Before Bubble Sort
[8, 7, 1, 2, 5]
Array arr1 After Optimized Bubble Sort
steps quantity, optimized = 3
[1, 2, 5, 7, 8]

బబుల్ క్రమబద్ధీకరణ ఎంత సమర్థవంతంగా ఉంటుంది?

బబుల్ క్రమబద్ధీకరణ అనేది అమలు చేయడానికి సులభమైన అల్గారిథమ్‌లలో ఒకటి, కానీ అది సమర్థవంతంగా పని చేయదు. దీనికి ఒక జత సమూహ లూప్‌లు అవసరం. చెత్త సందర్భంలో అల్గోరిథం యొక్క ఆప్టిమైజ్ చేసిన సంస్కరణలో కూడా (డేటా సెట్‌లోని ప్రతి మూలకం కావలసిన దానికి రివర్స్ ఆర్డర్‌లో ఉంటుంది) ఔటర్ లూప్ డేటా సెట్‌లోని ప్రతి n మూలకాలకు ఒకసారి పునరావృతమవుతుంది . ఇన్నర్ లూప్ మొదటిసారిగా n సార్లు పునరావృతమవుతుంది, ( n-1 ) రెండవదానికి, మరియు మొదలైనవి. అందువల్ల, అన్ని n , మూలకాలను క్రమబద్ధీకరించడానికి, లూప్‌లను n*(n-1)/2 సార్లు అమలు చేయాలి . ఇది O(n ² ) అని పిలుస్తుందిసమయం సంక్లిష్టత మరియు అల్గోరిథం శ్రేణి యొక్క 1000 మూలకాల కోసం దాదాపు 500 000 పోలికలను చేస్తుంది. అయినప్పటికీ, బబుల్ క్రమబద్ధీకరణ అల్గోరిథం మెమరీ వినియోగంలో చాలా ప్రభావవంతంగా ఉంటుంది (మెమరీ సంక్లిష్టత O(n) ) మరియు దాదాపుగా క్రమబద్ధీకరించబడిన చిన్న డేటాసెట్‌లకు నిజంగా మంచిది.