Java'da bir int dizisini nasıl tersine çevirebilirim?

Java bir int dizi ters çalışıyorum.

Bu yöntem diziyi tersine çevirmez.

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

Sorun nedir?

Bir int dizisini tersine çevirmek için, orta noktaya ulaşıncaya kadar öğeleri aşağıdaki gibi değiştirebilirsiniz:

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

Bunu yaparken, her öğeyi iki kez değiştirirsiniz, böylece sonuç ilk listeyle aynı olur.

Commons.Lang ile kullanabilirsiniz.

ArrayUtils.reverse(int[] array)

Çoğu zaman, sorununuzu hallederken birim olarak test edilmiş ve kullanıcı tarafından test edilmiş kolayca erişilebilen kitaplıklara sadık kalmak daha hızlı ve daha hatalıdır.

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()java.util.Lists'yi tersine çevirebilir ve java.util.Arrays.asList()kendisine ilettiğiniz belirli diziyi saran bir liste döndürür, bu nedenle yourArrayçağrıldıktan sonra tersine çevrilirCollections.reverse() .

Maliyet yalnızca bir List nesnesinin oluşturulmasıdır ve ek kitaplığa gerek yoktur.

Benzer bir çözüm Tarık ve yorumcularının cevabında da sunuldu, ancak bence bu cevap daha kısa ve daha kolay çözümlenebilir olacaktı.

Döngünün her yinelemesinde takas ettiğiniz endeksleri takip etmek için açık değişkenler bildirirseniz, algoritmanın mantığını takip etmenin biraz daha kolay olduğunu düşünüyorum.

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

Ben de bunu bir süre döngü içinde daha okunabilir düşünüyorum.

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

Burada, çoğunlukla diziyi yerinde değiştirmeye odaklanan birçok cevap var. Ancak tamlık uğruna, orijinal diziyi korumak ve yeni bir ters dizi oluşturmak için Java akışlarını kullanan başka bir yaklaşım:

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

Guava ile:

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

Java 8 durumunda, IntStreamtamsayı dizisini tersine çevirmek için de kullanabiliriz :

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]

Döngü için basit!

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

Bu sana yardım edecek

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

Kişisel olarak böyle çözerdim. Parametreli yöntemi oluşturmanın ardındaki neden, herhangi bir dizinin sıralanmasına izin vermektir ... sadece tam sayılarınız değil.

Umarım ondan bir şey çıkarırsın.

@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ınız yalnızca çalışır length = 0, 1. Deneyebilirsin :

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

Daha ilkel verilerle (yani, char, bayt, int vb.) Çalışıyorsanız, eğlenceli XOR işlemleri yapabilirsiniz.

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

Diziyi geriye doğru yinelemek en etkilidir.

Aaron'un çözümü bu vi bu çağrı yapar Collections.reverse(list);mı emin değilim Herkes biliyor mu?

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

Bu şekilde yapmak hatalar için çok daha olası olmaz mı?

    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;

O (n) zaman karmaşıklığı ve o (1) uzay karmaşıklığı ile çözüm.

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

Bir Diziyi tersine çevirmenin 2 yolu.

1. For döngüsünü kullanma O (n / 2) zaman karmaşıklığına sahip öğeleri orta noktaya kadar değiştirin.

   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. Yerleşik işlevi kullanma (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));

   }

   Çıktı: [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]); 
        }
    }

Yukarıda bazı harika cevaplar var, ama ben böyle yaptım:

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

makinenizde çalıştırılacak tam program aşağıdadır.

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

Dizileri kullanan matris programları için bu iyi bir kaynak olacaktır .

Kodunuzun temp gibi görünmesini önlemek için XOR çözümünü kullanma

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

Daha iyi bir açıklama için bu bağlantıya bakın:

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

İşte herhangi bir tür dizisini tersine çevirmek için basit bir uygulama , artı tam / kısmi destek.

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

}

İşte ilgili Birim Testi

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

İşte ben geldim:

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

Sorun için bir çözüm bulmanın iki yolu vardır:

1. Uzayda bir dizi ters çevirin.

Adım 1. Başlangıç ​​ve bitiş dizinindeki öğeleri değiştirin.

Adım 2. Başlangıç ​​dizinini artırın bitiş dizinini azaltın.

Adım 3. Başlangıç ​​dizini <bitiş dizini olana kadar Adım 1 ve Adım 2'yi yineleyin

Bunun için zaman karmaşıklığı O (n) ve uzay karmaşıklığı O (1) olacaktır.

Uzayda bir diziyi tersine çevirmek için örnek kod şöyledir:

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. Bir yardımcı dizi kullanarak bir diziyi ters çevirin.

Adım 1. Verilen diziye eşit yeni bir boyut dizisi oluşturun.

Adım 2. Başlangıç ​​dizininden başlayarak, belirtilen diziden bitiş dizininden başlayarak öğeleri yeni diziye ekleyin.

Bunun için zaman karmaşıklığı O (n) ve uzay karmaşıklığı O (n) olacaktır

Yardımcı dizi ile bir diziyi tersine çevirmek için örnek kod şöyledir:

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

Ayrıca, bunu yapmak için Java'dan Koleksiyonlar API'sını kullanabiliriz.

Koleksiyonlar API'sı dahili olarak aynı tersi alan yaklaşımını kullanır.

Koleksiyonlar API'sını kullanmak için örnek kod şöyledir:

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

    }