Bagaimana cara membalikkan array int di Jawa?

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?

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.

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.

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

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.

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

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

Dengan jambu biji:

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

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]

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

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

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

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

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
}

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

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?

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

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

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;

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

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]

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

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

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.

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/

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

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

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

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

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

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

    }