ஜாவாவில் ஒரு வரிசையை மாற்றவும்

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

ஒரு வரிசையை எப்படி மாற்றுவது

ஒரு வரிசையை மாற்றியமைக்க பல வழிகள் உள்ளன, இங்கே நாம் 5 ஐக் கருதுகிறோம். விருப்பம் 1 க்கு, அசல் வரிசையின் (இறங்கும்) முடிவில் இருந்து ஏறுவரிசையில் நிரப்பப்பட்ட கூடுதல் வரிசையைப் பயன்படுத்தி ஒரு அணியானது தலைகீழாக மாற்றப்படுகிறது, விருப்பம் 2 இல் ஒரு இன்-பிளேஸ் ரிவர்சல். தொடக்கத்திலும் முடிவிலும் உள்ள வரிசை உறுப்புகள் மாற்றப்பட்டால், விருப்பம் 3 இல், விருப்பத்தேர்வு 4 இல், List.add() மற்றும் List.remove() இல், கலெக்ஷன்ஸ் ஃப்ரேம்வொர்க்கிலிருந்து தலைகீழ் () முறை மாற்றியமைக்கப் பயன்படுத்தப்படுகிறது. பயன்படுத்தப்படுகின்றன, இறுதியாக, விருப்பம் 5 இல், மறுநிகழ்வு பயன்படுத்தப்படுகிறது.

விருப்பம் 1: கூடுதல் வரிசையைப் பயன்படுத்தி ஒரு வரிசையைத் திருப்புதல்

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

import java.util.Arrays;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       int[] array = {7, 8, 9, 10, 11};
       System.out.println("Array : " + Arrays.toString(array)); // print array

       // Call function to get reversed array
       int[] reversedArray = reverse(array);
       System.out.println("Reversed array : " + Arrays.toString(reversedArray)); // print reversed array
   }

   // Method returns a new reversed array, based on the array which was passed to it.
   static int[] reverse(int[] array) {
       int[] newArray = new int[array.length];

       for (int i = 0; i < array.length; i++) {
           newArray[array.length - 1 - i] = array[i];
       }

       return newArray;
   }
}

இந்த எடுத்துக்காட்டில், ஒரு வரிசையை மாற்றியமைத்து, அதற்கு அனுப்பப்பட்ட வரிசையின் அடிப்படையில் புதிய தலைகீழ் வரிசையை வழங்கும் முறையை நாங்கள் எழுதினோம். வரிசை முக்கியமாக அறிவிக்கப்பட்டது , பின்னர் ஒரு முறை, தலைகீழ் என அழைக்கப்படுகிறது. முறைக்கான வாதம் வரிசை. முறை தலைகீழாக , ஒரு புதிய வரிசை, newArray உருவாக்கப்பட்டது மற்றும் வரிசையின் அதே அளவு , முற்றிலும் காலியாக உள்ளது. புதிய வரிசையை நிரப்ப A for loop பயன்படுகிறது மற்றும் வரிசையின் முழு நீளத்திலும் செயல்படுகிறது. இது ஒரு வரிசையின் முதல் உறுப்பிலிருந்து தொடங்கி , அதை newArray இன் கடைசி உறுப்புக்கு ஒதுக்குவதன் மூலம் செய்யப்படுகிறது., பின்னர் எங்கள் அணிவரிசையின் இரண்டாவது உறுப்பை எடுத்து அதை newArray இன் இரண்டாவது கடைசி உறுப்புக்கு ஒதுக்குதல் மற்றும் பல; newArray பின்னோக்கி நிரப்பப்பட்டுள்ளது. for loop முடிந்ததும், newArray முழுவதுமாக நிரம்பியிருக்கும் மற்றும் இது வரிசையின் சரியான தலைகீழ் ஆகும் .

விருப்பம் 2: ஒரு வரிசையின் கூறுகளை தலைகீழ் வரிசையில் அச்சிடவும்

வரிசையைத் தலைகீழாக மாற்றுவதற்கான இந்த விருப்பத்திற்கு, கூடுதல் வரிசையைப் பயன்படுத்த வேண்டிய அவசியமில்லை, மேலும் அது வரிசைப் பட்டியலாக மாற்றப்படாது. அதற்கு பதிலாக வரிசை கூறுகள் தலைகீழ் வரிசையில் வைக்கப்படுகின்றன . உண்மையில் அவை மாற்றப்பட்டவை என்பதே இதன் பொருள். முதல் உறுப்பு கடைசி உறுப்புடன் மாற்றப்பட்டது, இரண்டாவது உறுப்பு கடைசியில் இருந்து இரண்டாவதாக மாற்றப்பட்டது, மற்றும் பல. A for loop பயன்படுத்தப்படுகிறது, இது முடிந்ததும், வரிசை தலைகீழாக மாற்றப்படும். குறியீடு இதுபோல் தெரிகிறது:

import java.util.Arrays;
/*
reversing an array in-place
*/
public class ReverseArrayDemo {

   public static void main(String[] args) {
       int[] array = {1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       arrayReverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }
//arrayReverse is a method that reverses array in-place
   static void arrayReverse(int[] array) {
       for (int i = 0; i < array.length / 2; i++) {
           int temp = array[i];
           array[i] = array[array.length - i - 1];
           array[array.length - i - 1] = temp;
       }
   }
}

அசல் வரிசையானது Arrays.toString(array) ஐப் பயன்படுத்தி ஒரு சரமாக அச்சிடப்படுகிறது , பின்னர் எங்கள் வரிசை ஒரு வாதமாக தலைகீழாக அனுப்பப்படுகிறது . for loop இல் உள்ள தலைகீழ் முறையில் , ஒரு மாறி, temp, உருவாக்கப்பட்டு பயன்படுத்தப்படுகிறது. ஃபார் லூப்பில், தலைகீழ் வரிசை மூன்று படிகளில் அடையப்படுகிறது:

1. வெப்பநிலைக்கு முதல் உறுப்பை ஒதுக்குகிறது
2. முதல் உறுப்புக்கு கடைசி உறுப்பை ஒதுக்குதல்
3. கடைசி உறுப்புக்கு வெப்பநிலையை ஒதுக்குகிறது

இது இந்த முறை இரண்டாவது உறுப்பு மற்றும் கடைசி உறுப்பு மற்றும் பலவற்றிலிருந்து இரண்டாவது உறுப்புக்கு மீண்டும் மேற்கொள்ளப்படுகிறது. இது வரிசையின் தொடர்ச்சியான உறுப்புகளுக்கு செய்யப்படுகிறது, ஆனால் லூப் வரிசை அளவின் பாதி வரை மட்டுமே திரும்பும். முக்கியமாக வரிசையின் எதிர் முனைகளில் உள்ள உறுப்புகள் மாற்றப்படுகின்றன. இந்த முறை 0 முதல் அளவிற்கு செல்லும் for loop ஐப் பயன்படுத்தும் முறையை விட இரண்டு மடங்கு வேகமாக இயங்கும் . இதன் விளைவாக, வரிசையின் தலைகீழ் வரிசை அடையப்படுகிறது மற்றும் தலைகீழ் வரிசையில் ஒரு வரிசையை எவ்வாறு அச்சிடுவது என்பதைக் காட்டுகிறோம் மற்றும் மதிப்புகள் அச்சிடப்படுகின்றன:

விருப்பம் 3: Collections.reverse() பயன்படுத்துதல்

ஜாவாவில், தற்போதுள்ள சேகரிப்பு கட்டமைப்பின் ஒரு பகுதியாக இருக்கும் தலைகீழ் முறையானது, ஒரு வரிசையை மாற்றியமைக்க பயன்படுத்தப்படலாம். தலைகீழாகச் செய்ய அதைப் பயன்படுத்துவோம்.

import java.util.Arrays;
import java.util.Collections;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = {1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       reverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }
//method that reverses an array
   static void reverse(Integer[] array) {
       Collections.reverse(Arrays.asList(array));
   }
}

முக்கியமாக , வரிசை 5 எண்களைக் கொண்ட முழு எண் வரிசையாக உருவாக்கப்பட்டு நிரப்பப்படுகிறது. இது பின்னர் Arrays.asList(array) ஐப் பயன்படுத்தி ஒரு பட்டியலாக அச்சிடப்படுகிறது , பின்னர் செயல்பாடு, தலைகீழ் , என அழைக்கப்படுகிறது மற்றும் வரிசை இந்த செயல்பாட்டிற்கு ஒரு வாதமாக அனுப்பப்படுகிறது. தலைகீழாக , Collections.reverse பயன்படுத்தப்படுகிறது, மேலும் இது வரிசை பட்டியலில் பயன்படுத்தப்படுகிறது, இது வரிசையை விட , Arrays.asList(array) . அடுத்த கட்டத்தில், System.out.println ஐப் பயன்படுத்தி தலைகீழ் வரிசையில் ஒரு வரிசையை எவ்வாறு அச்சிடுவது என்பதைக் காண்பிக்கிறோம் , மேலும் இந்த முறை ஒவ்வொரு உறுப்பும் ஒரே வரியில் அச்சிடப்படும்:

விருப்பம் 4: List.add() மற்றும் List.remove()ஐப் பயன்படுத்தி ஒரு வரிசையை மாற்றவும்

இந்த புதிய விருப்பத்தில், List.add() மற்றும் List.remove() ஆகியவை தலைகீழ் மாற்றத்தை செய்ய பயன்படுத்தப்படுகின்றன. இது செயல்படும் விதம் என்னவென்றால், வரிசை பட்டியலாக மாற்றப்பட்டு, பட்டியலின் கடைசி உறுப்பு அகற்றப்பட்டு பட்டியலின் தொடக்கத்தில் வைக்கப்படும். முழு பட்டியலையும் மீண்டும் மீண்டும் செய்த பிறகு, புதிய பட்டியல் அசலின் தலைகீழ் மாற்றமாகும். பிரதான() முறையில் , 5 எண்களைக் கொண்ட ஒரு வரிசை உருவாக்கப்படுகிறது. பின்னர் வரிசையின் அசல் நிலை கன்சோலுக்கு வெளியிடப்படும். இந்த வரிசை முறைக்கு ஒரு வாதமாக வைக்கப்படுகிறது, தலைகீழ்() . இந்த முறையானது, கடைசி உறுப்பை அகற்றி, வரிசையின் முன்புறத்தில் செருகுவதன் மூலம் செயல்படுகிறது. கடைசியாக, வரிசையின் புதிய (தலைகீழ்) நிலை கன்சோலுக்கு வெளியிடப்படுகிறது. தலைகீழாக ()முறை, தலைகீழ் மாற்றத்தை செயல்படுத்த add() மற்றும் remove() முறைகளை செயல்படுத்த, Arrays.asList(array) வழியாக வரிசை ஒரு பட்டியலில் எழுதப்படுகிறது . இந்த முறையானது, கடைசி உறுப்பை அகற்றி, வரிசையின் முன்புறத்தில் செருகுவதன் மூலம் செயல்படுகிறது. பின்வருபவை () பயன்பாடுகளின் படிகள் பின்வருமாறு. இது பட்டியலின் உறுப்புகளின் தலைகீழ் மாற்றத்தை மேற்கொள்ள லூப்பைப் பயன்படுத்துகிறது . இது ஒரு மாறி i ஐ துவக்குவதன் மூலம் செய்கிறது . ஆரம்பத்தில் i ஆனது 0 ஆக அமைக்கப்பட்டது. i = 0 , பட்டியலில் உள்ள list.size() - 1 இல் உள்ள உறுப்பு அகற்றப்படும், மேலும் i < list.size() - 1 க்குப் பிறகு இது எப்போதும் கடைசி உறுப்பாக இருக்கும்.. அகற்று() முறையானது அது அகற்றிய உறுப்பைத் தருவதால் , இந்த உறுப்பு இப்போது பட்டியலில் சேர்க்கப்பட்டது i = 0 , அதாவது தொடக்கத்தில் செருகப்பட்டது. பட்டியலில் மீதமுள்ளவை வலதுபுறமாக மாற்றப்படும், ஆனால் புதிய பட்டியலில் இன்னும் அதே எண்ணிக்கையிலான உறுப்புகள் உள்ளன, அதாவது அளவு . i , i = 1 இன் அடுத்த மதிப்புடன் for loop ஐ செயல்படுத்துவதைத் தொடர்கிறது , அதே படிகளின் தொகுப்பு மேற்கொள்ளப்படுகிறது, எனவே கடைசி உறுப்பு அகற்றப்பட்டு i = 1 இல் எண்களில் வைக்கப்படுகிறது மற்றும் பட்டியல் வலதுபுறமாக மாற்றப்பட்டது. i இன் கடைசி அதிகரிப்பு மதிப்பு மற்றும் பட்டியலில் உள்ள அனைத்து கூறுகளும் மாற்றப்படும் வரை இது தொடரும் . இரண்டாவது இல்நான் 0 இலிருந்து list.size() - 1 வரை இருக்கும் இடத்தில் i index i உடன் வரிசை உறுப்புக்கு அட்டவணையுடன் கூடிய பட்டியலின் லூப் உறுப்பு அமைக்கப்பட்டது . சுருக்கமாக, பயன்படுத்தப்படும் படிகள்: படிகள்:

1. நான் = 0
2. list.size() - 1 இல் உள்ள உறுப்பை அகற்றவும்
3. i = 0 இல் list.size() - 1 இல் இருந்த உறுப்பைச் செருகவும்
4. அதிகரிப்பு i
5. i இன் கடைசி அதிகரிப்பு மதிப்பு பயன்படுத்தப்படும் வரை 2 முதல் 4 படிகளை மீண்டும் செய்யவும் (படி 3 இல் i க்கான புதிய மதிப்புகளுடன்)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = new Integer[]{1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       reverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }

   static void reverse(Integer[] array) {
       List list = new ArrayList<>(Arrays.asList(array));

       for (int i = 0; i < list.size() - 1; i++) {
           list.add(i, list.remove(list.size() - 1));
       }

       for (int i = 0; i < list.size(); i++) {
           array[i] = list.get(i);
       }
   }
}

இந்த குறியீடு வெளியீட்டை அளிக்கிறது:

விருப்பம் 5: மறுநிகழ்வு மூலம் ஒரு வரிசையை மாற்றவும்

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

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = new Integer[]{1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       List list = new ArrayList<>(Arrays.asList(array));
       reverse(list);
       System.out.println("Array after reverse : " + Arrays.toString(list.toArray()));
   }

   public static void reverse(List list) {
       if (list== null || list.size() <= 1) {
           return;
       }

       Integer value = list.remove(0);

       reverse(list);

       list.add(value);
   }
}

வெளியீடு:

முடிவுரை

ஒரு வரிசையை மாற்றியமைப்பதற்கான 5 வெவ்வேறு வழிகளை இங்கே பார்த்தோம். Collections.reverse ஏற்கனவே இருக்கும், முயற்சித்த மற்றும் சோதிக்கப்பட்ட, Java செயல்பாடு என்பதால், சேகரிப்பு கட்டமைப்பைப் பயன்படுத்தும் விருப்பம் 3, பயன்படுத்துவதற்கான சிறந்த முறையாகும் . நிச்சயமாக மற்ற விருப்பங்களைப் பயன்படுத்தலாம், குறிப்பாக கற்றல் போது, ​​ஆனால் பொதுவாக நிலையான முறைகள், அவை இருந்தால், அவை பொதுவாக மிகவும் உகந்ததாக மற்றும் சோதிக்கப்பட்டவையாக இருக்கும். இருப்பினும், இது ஒரு நல்ல குறியீட்டு பயிற்சி மற்றும் ஜாவா ஜூனியருக்கான உங்கள் நேர்காணலில் வெற்றிபெற உதவும் என்பதால், இதுபோன்ற முறைகளை நீங்களே உருவாக்கலாம்.