Bagaimana cara membalikkan array int di Jawa?


238

Saya mencoba membalikkan array int di Jawa.

Metode ini tidak membalikkan array.

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

Apa yang salah dengan itu?


31
Saya melihat apa yang saya lakukan salah. Harus validData.length / 2. Kalau tidak, ia akan membalikkan dirinya sendiri lalu membatalkannya sendiri.
MichaelScott

4
Lihat en.wikipedia.org/wiki/In-place_algorithm yang berisi deskripsi versi yang benar dari algoritma ini.
Dean Povey

Jawaban:


284

Untuk membalikkan array int, Anda menukar item hingga mencapai titik tengah, seperti ini:

for(int i = 0; i < validData.length / 2; i++)
{
    int temp = validData[i];
    validData[i] = validData[validData.length - i - 1];
    validData[validData.length - i - 1] = temp;
}

Cara Anda melakukannya, Anda menukar setiap elemen dua kali, sehingga hasilnya sama dengan daftar awal.


Dan saya ingin menempatkan validData.length / 2bagian di luar for-loop.
Jin Kwon

7
@ Jin aku tidak akan. Itu hanya mengaburkan maknanya, dan saya yakin kompiler pengoptimalan akan melakukannya untuk Anda. Apa pun itu, tidak ada gunanya mengoptimalkan mikro sampai Anda memiliki bukti yang jelas dari pembuatan profil yang perlu / membantu.
Nicu Stiurca

9
@ JinKwon Itu akan seperti melakukan validData.length >> 1. Itu setara dan lebih cepat, tetapi membingungkan banyak programmer dan setiap kompiler yang baik secara otomatis akan melakukannya.
Justin

2
Anda hanya perlu melakukan perhitungan ini sekali validData.length - i - 1dan menyimpannya ke variabel.

Adakah yang bisa menyarankan pembalikan tanpa variabel temp !!
sg28

303

Dengan Commons.Lang , Anda cukup menggunakan

ArrayUtils.reverse(int[] array)

Sebagian besar waktu, lebih cepat dan lebih aman dari bug untuk bertahan dengan perpustakaan yang tersedia dengan mudah yang sudah diuji unit dan diuji oleh pengguna saat mereka menangani masalah Anda.


3
Saya akan lebih suka mengembalikan array yang terbalik (lulus) untuk gaya fungsional-seperti.
Laurent G

2
@ laurent-g agar adil: membalikkan array dengan cara ini lebih hemat memori, yang mungkin mengapa mereka melakukannya dengan cara ini.
Sirmyself

4
Maksud saya bukanlah salinan atau bukan salinan. Pesan saya menyatakan "(lulus)" untuk dikembalikan (setelah dibalik), sehingga dapat dikirimkan dalam ekspresi, tidak memerlukan pernyataan terpisah.
Laurent G

52
public class ArrayHandle {
    public static Object[] reverse(Object[] arr) {
        List<Object> list = Arrays.asList(arr);
        Collections.reverse(list);
        return list.toArray();
    }
}

11
Tentu saja akan. Daftar hanya dapat menampung Objek, bukan primitif, sehingga semua primitif ( intdalam hal ini) dibungkus dengan pembungkusnya masing-masing ( Integerdalam hal ini) dan dimasukkan ke dalam daftar. Anda lihat, Integers adalah objek. @ Tom
11.684

6
Hati-hati: Jika saya tidak salah array asli dimodifikasi. Untuk memperjelas Anda mungkin ingin tidak mengembalikan apa pun.
Andrea Zilio

3
@ 11684 Ya, daftar generik hanya bisa menampung Objek. Tetapi metode ini kecuali array. Array dapat menampung primitif. Karena int[]itu berbeda dengan Integer[]. Cobalah: Integer[] array = new int[5]. Anda akan mendapatkan kesalahan kompilasi. Inilah sebabnya mengapa Arrayskelas Java mendefinisikan banyak metode untuk bekerja dengan array primitif. Mencoba memberikan metode int[]ke atas akan menghasilkan sesuatu seperti The method reverse(Object[]) in the type MakeSimple is not applicable for the arguments (int[]). @Filip - algoritma di tempat menggunakan lebih sedikit memori dan berjalan lebih cepat.
Brian McCutchon

3
@ Andrea Sebenarnya tidak. Daftar yang dikembalikan oleh Arrays.asList()tidak merujuk ke array yang asli, juga array yang dikembalikan. Itulah salah satu masalah dengan metode ini: ia menggunakan tiga kali lipat memori dan melakukan tiga kali lipat pekerjaan sebagai algoritma di tempat.
Brian McCutchon

4
Metode ini sendiri mungkin berfungsi, tetapi orang tidak bisa memberikan int[]argumen sebagai metode ini ( "tipe tidak kompatibel: int [] tidak dapat dikonversi ke Objek []" ).
MC Kaisar

47
Collections.reverse(Arrays.asList(yourArray));

java.util.Collections.reverse()dapat membalikkan java.util.Listdan java.util.Arrays.asList()mengembalikan daftar yang membungkus array spesifik yang Anda lewati, oleh karena yourArrayitu dibalik setelah doa Collections.reverse().

Biaya hanya pembuatan satu objek-Daftar dan tidak ada perpustakaan tambahan yang diperlukan.

Solusi serupa telah disajikan dalam jawaban Tarik dan komentator mereka, tetapi saya pikir jawaban ini akan lebih ringkas dan lebih mudah diurai.


15
Untuk array objek, ini adalah solusi yang bagus. Tapi itu tidak berfungsi untuk array primitif. E. g. meneruskan suatu int[]ke asList(...)tidak akan mengembalikan List<Integer>, tetapi a List<int[]>, mengandung satu elemen. Ada AFAICS tidak ada cara bawaan yang sederhana untuk mengonversikan int[]ke Integer[].
Martin Rust

4
Ini tidak akan bekerja dengan array primitif ... koleksi dosnt mengembalikan nilai jadi sekarang Anda memiliki array yang tidak berguna sebagai daftar dalam memori
NightSkyCode

@MartinRust Java 8+: Arrays.stream(arr).boxed().collect(Collectors.toList())atauArrays.stream(arr).boxed().toArray(Integer[]::new)
Simon Forsberg

39

Saya pikir ini sedikit lebih mudah untuk mengikuti logika algoritma jika Anda mendeklarasikan variabel eksplisit untuk melacak indeks yang Anda tukar di setiap iterasi dari loop.

public static void reverse(int[] data) {
    for (int left = 0, right = data.length - 1; left < right; left++, right--) {
        // swap the values at the left and right indices
        int temp = data[left];
        data[left]  = data[right];
        data[right] = temp;
    }
}

Saya juga berpikir lebih mudah untuk melakukan ini dalam loop sementara.

public static void reverse(int[] data) {
    int left = 0;
    int right = data.length - 1;

    while( left < right ) {
        // swap the values at the left and right indices
        int temp = data[left];
        data[left] = data[right];
        data[right] = temp;

        // move the left and right index pointers in toward the center
        left++;
        right--;
    }
}

pertukaran sekolah lama terlihat lebih mudah tetapi ya ketika melibatkan nilai indeks array kiri, kanan, ... akan sangat membantu untuk debugging jika ada
Srinath Ganesh

Anda juga bisa menambahkan 'public static void swap (int [] data, int index1, int index2) {...}' dan menggunakannya dari 'reverse' seperti ini: swap (data, kiri, kanan).
pm_10

13

Sudah ada banyak jawaban di sini, sebagian besar berfokus pada memodifikasi array di tempat. Tetapi demi kelengkapan, berikut adalah pendekatan lain menggunakan aliran Java untuk mempertahankan array asli dan membuat array terbalik baru:

    int[] a = {8, 6, 7, 5, 3, 0, 9};
    int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length-i]).toArray();

10

Dengan jambu biji:

Collections.reverse(Ints.asList(array));

4
Ini brilian! Singkat dan efektif. Seperti semua asListmetode, ia menciptakan tampilan yang langsung menulis ke array backing (primitif). Saya pikir pemilih di sini keliru berpikir bahwa ini mengembalikan daftar kotak atau sesuatu.
Luke Usherwood

@LukeUsherwood mungkin masih ada beberapa overhead dari tinju dan unboxing saat memanggil get dan set pada setiap elemen. Tetapi saya setuju dengan Anda bahwa ini adalah solusi yang brilian.
Patrick Parker

Memang, itu patut disadari. Saya tidak berpikir itu akan menjadi masalah besar di sebagian besar kode saya secara pribadi bekerja dengan - daerah 'panas' kami didefinisikan dengan baik, sisanya adalah semacam 'kode lem'. Pada saat yang sama saya sadar bahwa memori churn juga menciptakan biaya "tersembunyi" tambahan yang tidak dikaitkan profiler dengan fungsi sebenarnya.
Luke Usherwood

@LukeUsherwood masih mengembalikan daftar kotak daripada array
prim

2
@AnthonyJClink Tidak yakin apa yang dimaksud dengan "itu", tetapi utilitas JDK Collections.reverseadalah metode batal. Ini beroperasi di tempat pada kelas internal Jambu yang membungkus int[](Karena tidak pernah menyimpan daftar kotak Integer, saya tidak akan menyebut kelas "daftar kotak", melainkan "Tampilan daftar array"). Tapi ya itu beroperasi melalui antarmuka melewati Integerobjek, jadi ini akan membuat banyak objek churn dan tinju sementara seperti yang disebutkan. Coba IntStreampustaka koleksi primitif atau di mana kinerja penting. (Trove, Koloboke, Eclipse Collections, ...)
Luke Usherwood

10

Dalam kasus Java 8 kita juga dapat menggunakan IntStreamuntuk membalikkan array bilangan bulat sebagai:

int[] sample = new int[]{1,2,3,4,5};
int size = sample.length;
int[] reverseSample = IntStream.range(0,size).map(i -> sample[size-i-1])
                      .toArray(); //Output: [5, 4, 3, 2, 1]

7

Sederhana untuk loop!

for (int start = 0, end = array.length - 1; start <= end; start++, end--) {
    int aux = array[start];
    array[start]=array[end];
    array[end]=aux;
}

4
Di masa mendatang, harap beri tahu penanya secara spesifik apa yang mereka lakukan salah, dan apa yang Anda lakukan dengan benar.
Kartik Chugh

1
ubah start <= endkestart < end
Leonard Pauli

5

Ini akan membantu Anda

int a[] = {1,2,3,4,5};
for (int k = 0; k < a.length/2; k++) {
    int temp = a[k];
    a[k] = a[a.length-(1+k)];
    a[a.length-(1+k)] = temp;
}

5
for(int i=validData.length-1; i>=0; i--){
  System.out.println(validData[i]);
 }

Sayangnya, ini adalah jawaban paling bersih yang tersedia di sini, karena setiap pengembang akan tahu bagaimana melakukannya dan tidak memerlukan instalasi paket yang diperpanjang.
HoldOffHunger

5

Inilah bagaimana saya akan menyelesaikannya secara pribadi. Alasan di balik pembuatan metode parametrized adalah untuk memungkinkan setiap array diurutkan ... bukan hanya bilangan bulat Anda.

Saya harap Anda mendapatkan sesuatu darinya.

@Test
public void reverseTest(){
   Integer[] ints = { 1, 2, 3, 4 };
   Integer[] reversedInts = reverse(ints);

   assert ints[0].equals(reversedInts[3]);
   assert ints[1].equals(reversedInts[2]);
   assert ints[2].equals(reversedInts[1]);
   assert ints[3].equals(reversedInts[0]);

   reverseInPlace(reversedInts);
   assert ints[0].equals(reversedInts[0]);
}

@SuppressWarnings("unchecked")
private static <T> T[] reverse(T[] array) {
    if (array == null) {
        return (T[]) new ArrayList<T>().toArray();
    }
    List<T> copyOfArray = Arrays.asList(Arrays.copyOf(array, array.length));
    Collections.reverse(copyOfArray);
    return copyOfArray.toArray(array);
}

private static <T> T[] reverseInPlace(T[] array) {
    if(array == null) {
        // didn't want two unchecked suppressions
        return reverse(array);
    }

    Collections.reverse(Arrays.asList(array));
    return array;
}

2
Tidak menyelesaikan masalah asli menggunakan primitif.
Melinda Green

Ada banyak cara untuk mengubah prims menjadi objek. Saya selalu merekomendasikan menghindari prima sedapat mungkin di java dan saya juga percaya bahwa itu harus didorong.
AnthonyJClink

Mengubah array primitif dengan panjang yang tidak diketahui menjadi array mungkin merupakan ide yang sangat buruk, terutama jika dilakukan tanpa menyadarinya. Java bukan Smalltalk. Primitif adalah bagian dari bahasa dan memiliki tempat mereka. Tidak masalah jika kita tidak menyukainya, kita harus menerimanya, dan menggunakannya jika perlu.
Melinda Green

1
Anda sebenarnya tidak perlu menyalin array, cukup Collections.reverse(asList(arraytoReverse)); return arrayToReverse;. asListhanyalah pembungkus di sekitar array, sehingga array asli dibalik.
Radiodef

3

Program Anda hanya akan berfungsi length = 0, 1. Anda dapat mencoba :

int i = 0, j = validData.length-1 ; 
while(i < j)
{
     swap(validData, i++, j--);  // code for swap not shown, but easy enough
}

3
Mungkin Anda bermaksud menukar sebagai kode pseudo untuk pertukaran inline daripada panggilan metode, tetapi jika tidak, itu tidak akan berhasil. Java melewati referensi sehingga tidak mungkin menulis metode swap untuk variabel.
Dean Povey

Maksud saya dengan cara apa pun Anda bisa mendapatkan v [i] & v [j] untuk bertukar. Saya sadar bagaimana pemanggilan metode bekerja di java. Untuk metode, Anda dapat melakukan sesuatu seperti swap (v, i ++, j--);
fastcodejava

1
Dean, array validData adalah objek, dilewatkan dengan referensi, sehingga metode swap () akan bekerja dengan sempurna.
Gaël Oberson

3

Jika bekerja dengan data yang lebih primitif (yaitu char, byte, int, dll) maka Anda dapat melakukan beberapa operasi XOR yang menyenangkan.

public static void reverseArray4(int[] array) {
    int len = array.length;
    for (int i = 0; i < len/2; i++) {
        array[i] = array[i] ^ array[len - i  - 1];
        array[len - i  - 1] = array[i] ^ array[len - i  - 1];
        array[i] = array[i] ^ array[len - i  - 1];
    }
}

1
Terlalu lucu untuk benar-benar digunakan dalam kode produksi tetapi tetap menyenangkan. Untuk kelucuan maksimal, gunakan operasi% = seperti ini: array [i]% = array [len - i - 1], dll.
Melinda Green

Serupa, tetapi sedikit lebih pendek:for (int m = x.length, i = --m / 2; ++i <= m;) { x[i] ^= x[m - i]; x[i] ^= x[m - i] ^= x[i]; }
Thomas Mueller

2

Paling efisien untuk hanya mengulangi array ke belakang.

Saya tidak yakin apakah solusi Harun melakukan ini untuk panggilan ini. Collections.reverse(list);Adakah yang tahu?


Iterasi mundur dari array membutuhkan array baru. Saya suka solusi yang diposting di atas yang melakukan pembalikan inline tanpa membuat array baru.
mmcdole

1
@Simucal mengapa membuat array baru? Ulangi saja.
Trejkaz

2
public void getDSCSort(int[] data){
        for (int left = 0, right = data.length - 1; left < right; left++, right--){
            // swap the values at the left and right indices
            int temp = data[left];
            data[left]  = data[right];
            data[right] = temp;
        }
    }

1
public void display(){
  String x[]=new String [5];
  for(int i = 4 ; i > = 0 ; i-- ){//runs backwards

    //i is the nums running backwards therefore its printing from       
    //highest element to the lowest(ie the back of the array to the front) as i decrements

    System.out.println(x[i]);
  }
}

1
ya saya telah mencoba kode yang sama dan jelas bersama dengan output int [] a = {1,3,5,2,6,7}; untuk (int i = a.length-1; i> = 0; i--) {System.out.print (a [i] + "");} `itu akan membalik array dari indeks terakhir ke indeks pertama
Rocket_03

1

Tidakkah melakukannya dengan cara ini jauh lebih tidak mungkin untuk kesalahan?

    int[] intArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int[] temp = new int[intArray.length];
    for(int i = intArray.length - 1; i > -1; i --){
            temp[intArray.length - i -1] = intArray[i];
    }
    intArray = temp;

1

Solusi dengan o (n) kompleksitas waktu dan o (1) kompleksitas ruang.

void reverse(int[] array) {
    int start = 0;
    int end = array.length - 1;
    while (start < end) {
        int temp = array[start];
        array[start] = array[end];
        array[end] = temp;
        start++;
        end--;
    }
}

Untuk diketahui, ini dapat disederhanakan menjadi kompleks untuk loop: for (int start = 0, end = array.length - 1; start < end; start++, end--) { ... }.
Tim Cooke

1

2 cara untuk membalikkan Array.

  1. Menggunakan Untuk loop dan menukar elemen sampai titik tengah dengan kompleksitas waktu O (n / 2).

    private static void reverseArray() {
    int[] array = new int[] { 1, 2, 3, 4, 5, 6 };
    
    for (int i = 0; i < array.length / 2; i++) {
        int temp = array[i];
        int index = array.length - i - 1;
        array[i] = array[index];
        array[index] = temp;
    }
    System.out.println(Arrays.toString(array));

    }

  2. Menggunakan fungsi bawaan (Collections.reverse ())

    private static void reverseArrayUsingBuiltInFun() {
    int[] array = new int[] { 1, 2, 3, 4, 5, 6 };
    
    Collections.reverse(Ints.asList(array));
    System.out.println(Arrays.toString(array));

    }

    Output: [6, 5, 4, 3, 2, 1]


3
Apa Ints?
CodingNow

@CodingNow, ini adalah salah satu kelas pembantu utilitas Guava - lihat di sini
mrec

1
    public static void main(String args[])    {
        int [] arr = {10, 20, 30, 40, 50}; 
        reverse(arr, arr.length);
    }

    private static void reverse(int[] arr,    int length)    {

        for(int i=length;i>0;i--)    { 
            System.out.println(arr[i-1]); 
        }
    }

1

Ada beberapa jawaban bagus di atas, tetapi ini adalah bagaimana saya melakukannya:

public static int[] test(int[] arr) {

    int[] output = arr.clone();
    for (int i = arr.length - 1; i > -1; i--) {
        output[i] = arr[arr.length - i - 1];
    }
    return output;
}

0

di bawah ini adalah program lengkap untuk dijalankan di mesin Anda.

public class ReverseArray {
    public static void main(String[] args) {
        int arr[] = new int[] { 10,20,30,50,70 };
        System.out.println("reversing an array:");
        for(int i = 0; i < arr.length / 2; i++){
            int temp = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }   
    }
}

Untuk program pada matriks menggunakan array, ini akan menjadi sumber yang bagus. Pergi melalui tautan.


0

Menggunakan solusi XOR untuk menghindari variabel temp kode Anda akan terlihat seperti

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

Lihat tautan ini untuk penjelasan yang lebih baik:

http://betterexplained.com/articles/swap-two-variables-using-xor/


0
private static int[] reverse(int[] array){
    int[] reversedArray = new int[array.length];
    for(int i = 0; i < array.length; i++){
        reversedArray[i] = array[array.length - i - 1];
    }
    return reversedArray;
} 

4
Silakan pertimbangkan untuk menambahkan penjelasan pada jawaban Anda. Jawaban hanya kode tidak menjelaskan apa pun.
rgettman

0

Berikut ini adalah implementasi sederhana, untuk membalikkan array jenis apa pun , ditambah dukungan penuh / parsial .

import java.util.logging.Logger;

public final class ArrayReverser {
 private static final Logger LOGGER = Logger.getLogger(ArrayReverser.class.getName());

 private ArrayReverser () {

 }

 public static <T> void reverse(T[] seed) {
    reverse(seed, 0, seed.length);
 }

 public static <T> void reverse(T[] seed, int startIndexInclusive, int endIndexExclusive) {
    if (seed == null || seed.length == 0) {
        LOGGER.warning("Nothing to rotate");
    }
    int start = startIndexInclusive < 0 ? 0 : startIndexInclusive;
    int end = Math.min(seed.length, endIndexExclusive) - 1;
    while (start < end) {
        swap(seed, start, end);
        start++;
        end--;
    }
}

 private static <T> void swap(T[] seed, int start, int end) {
    T temp =  seed[start];
    seed[start] = seed[end];
    seed[end] = temp;
 }  

}

Berikut adalah Unit Test yang sesuai

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;

import org.junit.Before;
import org.junit.Test;

public class ArrayReverserTest {
private Integer[] seed;

@Before
public void doBeforeEachTestCase() {
    this.seed = new Integer[]{1,2,3,4,5,6,7,8};
}

@Test
public void wholeArrayReverse() {
    ArrayReverser.<Integer>reverse(seed);
    assertThat(seed[0], is(8));
}

 @Test
 public void partialArrayReverse() {
    ArrayReverser.<Integer>reverse(seed, 1, 5);
    assertThat(seed[1], is(5));
 }
}

0

Inilah yang saya buat:

// solution 1 - boiler plated 
Integer[] original = {100, 200, 300, 400};
Integer[] reverse = new Integer[original.length];

int lastIdx = original.length -1;
int startIdx = 0;

for (int endIdx = lastIdx; endIdx >= 0; endIdx--, startIdx++)
   reverse[startIdx] = original[endIdx];

System.out.printf("reverse form: %s", Arrays.toString(reverse));

// solution 2 - abstracted 
// convert to list then use Collections static reverse()
List<Integer> l = Arrays.asList(original);
Collections.reverse(l);
System.out.printf("reverse form: %s", l);

0

Ada dua cara untuk memiliki solusi untuk masalah ini:

1. Membalikkan array dalam ruang.

Langkah 1. Tukar elemen pada awal dan akhir indeks.

Langkah 2. Tambahkan indeks awal, turunkan indeks akhir.

Langkah 3. Ulangi Langkah 1 dan Langkah 2 hingga mulai indeks <indeks akhir

Untuk ini, kompleksitas waktu akan menjadi O (n) dan kompleksitas ruang akan menjadi O (1)

Kode contoh untuk membalikkan array dalam ruang adalah seperti:

public static int[] reverseAnArrayInSpace(int[] array) {
    int startIndex = 0;
    int endIndex = array.length - 1;
    while(startIndex < endIndex) {
        int temp = array[endIndex];
        array[endIndex] = array[startIndex];
        array[startIndex] = temp;
        startIndex++;
        endIndex--;
    }
    return array;
}

2. Membalikkan array menggunakan array bantu.

Langkah 1. Buat array ukuran baru yang sama dengan array yang diberikan.

Langkah 2. Masukkan elemen ke array baru mulai dari indeks awal, dari array yang diberikan mulai dari indeks akhir.

Untuk ini, kompleksitas waktu akan menjadi O (n) dan kompleksitas ruang akan menjadi O (n)

Kode contoh untuk membalikkan array dengan array bantu adalah seperti:

public static int[] reverseAnArrayWithAuxiliaryArray(int[] array) {
    int[] reversedArray = new int[array.length];
    for(int index = 0; index < array.length; index++) {
        reversedArray[index] = array[array.length - index -1]; 
    }
    return reversedArray;
}

Kami juga dapat menggunakan API Koleksi dari Jawa untuk melakukan ini.

API Koleksi secara internal menggunakan pendekatan membalikkan ruang yang sama.

Kode contoh untuk menggunakan API Koleksi adalah seperti:

public static Integer[] reverseAnArrayWithCollections(Integer[] array) {
    List<Integer> arrayList = Arrays.asList(array);
    Collections.reverse(arrayList);
    return arrayList.toArray(array);
}

0
static int[] reverseArray(int[] a) {
     int ret[] = new int[a.length];
     for(int i=0, j=a.length-1; i<a.length && j>=0; i++, j--)
         ret[i] = a[j];
     return ret;
}

0
 public static int[] reverse(int[] array) {

    int j = array.length-1;
    // swap the values at the left and right indices //////
        for(int i=0; i<=j; i++)
        {
             int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
           j--;
        }

         return array;
    }

      public static void main(String []args){
        int[] data = {1,2,3,4,5,6,7,8,9};
        reverse(data);

    }
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.