குமிழி வரிசை ஜாவா

நிரலாக்கத்தில் வரிசைப்படுத்தும் முறைகள் பற்றி நீங்கள் எப்போதாவது கேள்விப்பட்டிருந்தால், பெரும்பாலும் அது குமிழி வரிசை வழிமுறையாக இருக்கலாம். இது பிரபலமான ஒன்று. ஒவ்வொரு புரோகிராமருக்கும் குமிழி வரிசை தெரியும் (அல்லது கற்றல் போது குறைந்தபட்சம் அது பற்றி கேள்விப்பட்டது) இது உலகின் சிறந்த வரிசையாக்க வழிமுறை என்பதால் அல்ல, ஆனால் எளிதானது. இந்த அல்காரிதம் பொதுவாக கற்றல் நோக்கங்களுக்காகப் பயன்படுத்தப்படுகிறது அல்லது உங்கள் ஜாவா ஜூனியர் நேர்காணலில் நீங்கள் அதை ஒரு பணியாகப் பெறலாம். Java Bubble sort அல்காரிதம் புரிந்து கொள்ள மிகவும் எளிதானது, இருப்பினும் இது ஒரு திறமையான ஒன்றல்ல. எப்படியிருந்தாலும், அதைக் கண்டுபிடிப்போம்.

வரிசைப்படுத்துவது என்றால் என்ன

முதலில், வரிசையாக்கம் என்றால் என்ன, ஜாவா நிரல்களில் நாம் என்ன வரிசைப்படுத்தலாம் என்பதை நீங்கள் புரிந்து கொள்ள வேண்டும். இரண்டு அல்லது அதற்கு மேற்பட்ட தனிமங்கள் அல்லது பொருள்களை அவற்றின் ஏதேனும் ஒரு பண்புக்கூறின் மூலம் நாம் ஒப்பிட்டுப் பார்க்க முடிந்தால், இந்தப் பண்புக்கூறின் மூலம் அவற்றை வரிசைப்படுத்தலாம் என்று அர்த்தம். எடுத்துக்காட்டாக, ஏறுவரிசை அல்லது இறங்கு வரிசையில் எண்கள் அல்லது அகர வரிசைப்படி சொற்கள். எனவே, கூறுகள் ஒருவருக்கொருவர் ஒப்பிடத்தக்கதாக இருக்க வேண்டும். மூலம், என்ன கூறுகள்? ஜாவாவில், சேகரிப்புகளின் கூறுகளை ஒப்பிடலாம். எடுத்துக்காட்டாக, முழு எண்கள், சரங்கள் மற்றும் பலவற்றின் வரிசை அல்லது வரிசைப்பட்டியலை நாம் வரிசைப்படுத்தலாம்.

குமிழி வரிசை எப்படி வேலை செய்கிறது

முழு எண்களின் வரிசையை ஏறுவரிசையில் வரிசைப்படுத்த வேண்டும், அதாவது சிறியது முதல் பெரிய எண் வரை. முதலில், நாங்கள் முழு வரிசையிலும் சென்று ஒவ்வொரு 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 இன் மதிப்பு, இந்த வரிசையில் மிகப்பெரியது, பட்டியலின் முடிவில் சரியான நிலைக்கு வந்தது. Bubble sort algorithm வேலை செய்யும் முதல் படியின் விளைவு அடுத்த வரிசை: படி 2. (7,1), (7,2) மற்றும் (7,5) உடன் அதையே செய்தல் 7 இப்போது இறுதி நிலையில் உள்ளது, மேலும் அதை பட்டியலின் "வால்" உடன் ஒப்பிட தேவையில்லை, அது ஏற்கனவே வரிசைப்படுத்தப்பட்டுள்ளது. Bubble sort algorithm வேலை செய்யும் இரண்டாவது படியின் விளைவு அடுத்த வரிசை: நீங்கள் பார்ப்பது போல், இந்த வரிசை ஏற்கனவே வரிசைப்படுத்தப்பட்டுள்ளது. எப்படியிருந்தாலும், குமிழி வரிசைப்படுத்தும் அல்காரிதம் இன்னும் ஒரு முறையாவது செயல்பட வேண்டும். படி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) ) மற்றும் கிட்டத்தட்ட வரிசைப்படுத்தப்பட்ட சிறிய தரவுத்தொகுப்புகளுக்கு மிகவும் நல்லது.