Balikkan Array di Jawa

Tatasusunan kerap digunakan dalam pengekodan dan merupakan satu cara untuk menyimpan berbilang nilai daripada jenis yang sama dalam satu pembolehubah. Mungkin terdapat banyak sebab mengapa pengekod mungkin mahu membalikkan tatasusunan. Ia mungkin perlu untuk membalikkan tatasusunan, sebagai contoh, apabila logik masalah perlu bermula dengan elemen terakhir. Dalam kes ini, amalan terbaik ialah melakukan pembalikan dan kemudian menggunakan tatasusunan terbalik jika perlu dalam kod. Lebih-lebih lagi, membalikkan tatasusunan adalah tugas yang sangat popular dalam wawancara Java Juniors.

Cara Membalikkan Tatasusunan

Terdapat banyak cara untuk membalikkan tatasusunan, dan di sini kita menganggap 5. Untuk Pilihan 1, tatasusunan diterbalikkan menggunakan tatasusunan tambahan yang diisi dalam tertib menaik dari penghujung tatasusunan asal (menurun), dalam Pilihan 2 pembalikan di tempat dijalankan di mana elemen tatasusunan pada permulaan dan akhir ditukar, dalam Pilihan 3, kaedah reverse() daripada rangka kerja Collections digunakan untuk melakukan pembalikan, dalam Pilihan 4, List.add() dan List.remove() digunakan, dan akhirnya, dalam Pilihan 5, rekursi digunakan.

Pilihan 1: Membalikkan Tatasusunan menggunakan Tatasusunan Tambahan

Mari kita tulis kaedah mudah untuk membalikkan tatasusunan menggunakan tatasusunan tambahan . Pilihan ini menggunakan tatasusunan tambahan yang diisi bermula dengan elemen terakhir tatasusunan asal dalam tertib menurun, iaitu elemen pertama adalah sama dengan elemen terakhir dalam tatasusunan asal, kedua adalah sama dengan kedua dari terakhir dan seterusnya hidup sehingga tatasusunan tambahan diisi.

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;
   }
}

Dalam contoh ini, kami menulis kaedah yang membalikkan tatasusunan dan mengembalikan tatasusunan terbalik baharu, berdasarkan tatasusunan yang dihantar kepadanya. tatasusunan diisytiharkan dalam main dan kemudian kaedah, reverse , dipanggil. Hujah kepada kaedah ialah tatasusunan. Dalam kaedah reverse , tatasusunan baharu, newArray , dicipta dan saiznya sama dengan tatasusunan , hanya kosong sepenuhnya. A for loop digunakan untuk mengisi newArray dan beroperasi sepanjang keseluruhan array. Ini dilakukan dengan bermula dengan elemen pertama tatasusunan dan memberikannya kepada elemen terakhir newArray, kemudian mengambil elemen kedua tatasusunan kami dan memberikannya kepada elemen kedua terakhir newArray , dan seterusnya; newArray diisi ke belakang. Apabila gelung for selesai, newArray penuh sepenuhnya dan merupakan kebalikan tepat tatasusunan .

Pilihan 2: Cetak Elemen Tatasusunan dalam Susunan Songsang

Untuk pilihan ini untuk membalikkan tatasusunan, tidak perlu menggunakan tatasusunan tambahan dan ia tidak ditukar kepada senarai tatasusunan. Sebaliknya elemen tatasusunan diletakkan dalam susunan terbalik di tempat . Ini bermakna bahawa mereka, sebenarnya, bertukar. Elemen pertama ditukar dengan elemen terakhir, elemen kedua ditukar dengan elemen kedua dari terakhir, dan seterusnya. A untuk gelung digunakan dan apabila ini telah selesai, tatasusunan akan diterbalikkan. Kod kelihatan seperti ini:

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;
       }
   }
}

Tatasusunan asal dicetak sebagai String menggunakan Arrays.toString(array) , dan kemudian tatasusunan kami dihantar sebagai hujah ke sebaliknya . Dalam kaedah terbalik dalam gelung for , pembolehubah, temp, dicipta dan digunakan. Dalam gelung for susunan terbalik dicapai dalam tiga langkah:

1. memberikan elemen pertama kepada temp
2. memberikan elemen terakhir kepada elemen pertama
3. menetapkan temp kepada elemen terakhir

Ini kemudiannya dijalankan sekali lagi kali ini untuk elemen kedua dan kedua dari elemen terakhir, dan seterusnya. Ini dilakukan untuk elemen berturut-turut tatasusunan tetapi gelung hanya melelang sehingga separuh saiz tatasusunan. Pada asasnya unsur-unsur di hujung bertentangan tatasusunan ditukar. Kaedah ini akan berjalan dua kali lebih pantas daripada kaedah menggunakan gelung for daripada 0 kepada saiz. Akibatnya susunan terbalik tatasusunan dicapai dan kami ditunjukkan cara mencetak tatasusunan dalam susunan terbalik dan nilainya dicetak:

Pilihan 3: Menggunakan Collections.reverse()

Di Java, kaedah terbalik , yang merupakan sebahagian daripada rangka kerja Koleksi sedia ada, boleh digunakan untuk membalikkan tatasusunan. Mari gunakannya untuk melakukan pembalikan.

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));
   }
}

Dalam main , tatasusunan dibuat dan diisi sebagai tatasusunan Integer dengan 5 nombor. Ia kemudian dicetak sebagai senarai menggunakan Arrays.asList(array) dan kemudian fungsi, reverse , dipanggil dan tatasusunan dihantar sebagai hujah ke dalam fungsi ini. Secara songsang , Collections.reverse digunakan dan ini digunakan pada senarai tatasusunan, Arrays.asList(array) , dan bukannya tatasusunan itu sendiri. Kemudian dalam langkah seterusnya kita ditunjukkan cara mencetak tatasusunan dalam susunan terbalik menggunakan System.out.println , dan kali ini setiap elemen dicetak pada baris yang sama:

Pilihan 4: Balikkan Tatasusunan menggunakan List.add() dan List.remove()

Dalam pilihan baharu ini, List.add() dan List.remove() digunakan untuk melakukan pembalikan. Cara ini berfungsi ialah tatasusunan ditukar kepada senarai dan elemen terakhir senarai dialih keluar dan diletakkan pada permulaan senarai. Selepas keseluruhan senarai telah diulang, senarai baharu adalah pembalikan daripada yang asal. Dalam kaedah main() , tatasusunan dibuat yang terdiri daripada 5 nombor. Kemudian keadaan asal tatasusunan dikeluarkan ke konsol. Tatasusunan ini kemudiannya dimasukkan sebagai hujah kepada kaedah, reverse() . Kaedah ini pada asasnya berfungsi dengan mengalih keluar elemen terakhir dan memasukkannya di hadapan tatasusunan. Akhir sekali, keadaan baharu (terbalik) tatasusunan dikeluarkan kepada konsol. Di sebaliknya()kaedah, tatasusunan ditulis ke Senarai melalui Arrays.asList(array) , untuk membolehkan kaedah add() dan remove() menjalankan pembalikan. Kaedah ini pada asasnya berfungsi dengan mengalih keluar elemen terakhir dan memasukkannya di hadapan tatasusunan. Langkah-langkah reverse() menggunakan adalah seperti berikut. Ia menggunakan gelung for untuk melakukan pembalikan unsur-unsur senarai. Ia melakukan ini dengan memulakan pembolehubah i . Pada mulanya i ditetapkan kepada 0. Apabila i = 0 , elemen di list.size() - 1 dalam senarai dialih keluar, dan ini akan sentiasa menjadi elemen terakhir sejak i <list.size() - 1. Memandangkan kaedah remove() mengembalikan elemen yang telah dialih keluar, elemen ini kini ditambah pada senarai di index i = 0 , iaitu, dimasukkan pada permulaan. Baki senarai kemudian dialihkan ke kanan tetapi senarai baharu masih mempunyai bilangan elemen yang sama, iaitu saiz . Meneruskan pelaksanaan gelung for dengan nilai seterusnya i , i = 1 , set langkah yang sama dijalankan supaya elemen terakhir dikeluarkan dan dimasukkan ke dalam nombor pada i = 1 dan senarai itu beralih ke kanan. Ini berterusan sehingga nilai tambahan terakhir i dan semua elemen dalam senarai telah ditukar. Dalam kedua untukelemen gelung senarai dengan indeks i ditetapkan kepada elemen tatasusunan dengan indeks i di mana i adalah dari 0 hingga list.size() - 1 . Sebagai rumusan, langkah-langkah yang digunakan ialah: Langkah:

1. i = 0
2. alih keluar elemen di list.size() - 1
3. masukkan elemen, yang berada di list.size() - 1 , pada i = 0
4. kenaikan i
5. ulangi langkah 2 hingga 4 (dengan nilai baharu untuk i pada langkah 3) sehingga nilai tambahan terakhir i digunakan

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);
       }
   }
}

Kod ini memberikan output:

Pilihan 5: Balikkan Tatasusunan dengan Ulangan

Kaedah rekursi digunakan secara meluas dalam pengekodan dan boleh digunakan untuk mencipta kaedah yang cekap tentang cara membalikkan tatasusunan. Dalam pilihan ini, tatasusunan ditukar kepada senarai dan kemudian kod masuk ke kaedah reverse() setiap kali mengalih keluar elemen terakhir pada penghujung senarai dan senarai mempunyai nilai yang dialih keluar ditambah kepadanya dalam susunan terbalik. Seperti dalam kaedah sebelumnya, tatasusunan dibuat yang terdiri daripada 5 nombor. Ia kemudiannya diluluskan sebagai hujah ke dalam fungsi, reverse() . Dalam reverse() perkara pertama yang dilakukan ialah menukar tatasusunan menjadi senarai dan menyemak saiz senarai. Jika ia hanya mempunyai satu elemen atau adalah nol maka kaedah itu selesai dan kembali. Jika tidak, elemen pertama dialih keluar, tetapi disalin ke Integer, nilai . Kaedah reverse() kemudian dipanggil semula dan rekursi bermula semula. Apabila fungsi dimasukkan, langkah yang sama dijalankan, pemeriksaan saiz di mana, jika senarai lebih besar daripada 1 langkah seterusnya adalah untuk mengalih keluar elemen pertama dan kemudian melakukan rekursi sekali lagi. Apabila saiz senarai ialah 1, reverse() kembali ke tempat ia dipanggil dan kemudian senarai mempunyai setiap nilai yang ditambahkan padanya untuk membinanya menjadi songsang tepat senarai asal.

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);
   }
}

Outputnya ialah:

Kesimpulan

Jadi di sini kita telah melihat 5 cara berbeza untuk membalikkan tatasusunan. Pilihan 3, yang menggunakan rangka kerja Collections, mungkin merupakan kaedah terbaik untuk digunakan memandangkan Collections.reverse ialah fungsi Java yang sedia ada, dicuba dan diuji. Sudah tentu pilihan lain boleh digunakan, terutamanya semasa belajar, tetapi secara amnya kaedah standard, jika wujud, adalah yang terbaik kerana ia biasanya sangat dioptimumkan dan diuji. Walau bagaimanapun, anda boleh mencipta kaedah sedemikian sendiri kerana ini adalah latihan pengekodan yang baik dan akan membantu anda berjaya dalam temu duga anda untuk Java Junior.