wake-up-neo.com

Wie kann ich ein int-Array in Java umkehren?

Ich versuche, ein int-Array in Java umzukehren.

Diese Methode kehrt das Array nicht um. 

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

Was ist daran falsch?

200
MichaelScott

Um ein int-Array umzukehren, tauschen Sie Elemente nach oben, bis Sie den Mittelpunkt erreichen, wie folgt:

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

So wie Sie es tun, tauschen Sie jedes Element zweimal aus, sodass das Ergebnis der ursprünglichen Liste entspricht.

253
3lectrologos

Mit Commons.Lang können Sie einfach verwenden 

ArrayUtils.reverse(int[] array)

Die meiste Zeit ist es schneller und sicherer, sich an leicht verfügbare Bibliotheken zu halten, die bereits Unit-getestet und vom Benutzer getestet wurden, wenn sie sich um Ihr Problem kümmern.

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

Ich denke, es ist ein bisschen einfacher, der Logik des Algorithmus zu folgen, wenn Sie explizite Variablen deklarieren, um die Indizes zu verfolgen, die Sie bei jeder Iteration der Schleife wechseln.

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

Ich denke auch, dass es in einer while-Schleife besser lesbar ist.

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--;
    }
}
37
Bill the Lizard
Collections.reverse(Arrays.asList(yourArray));

Java.util.Collections.reverse() kann Java.util.Lists umkehren und Java.util.Arrays.asList() gibt eine Liste zurück, die das spezifische Array umgibt, an das Sie übergeben werden. Daher wird yourArray nach dem Aufruf von Collections.reverse() umgekehrt.

Die Kosten sind nur die Erstellung eines Listenobjekts, und es sind keine zusätzlichen Bibliotheken erforderlich.

Eine ähnliche Lösung wurde in der Antwort von Tarik und ihren Kommentatoren vorgestellt, aber ich denke, diese Antwort wäre prägnanter und leichter zu analysieren.

33
escitalopram

Hier gibt es bereits viele Antworten, die sich hauptsächlich auf die Änderung des Arrays vor Ort konzentrieren. Der Vollständigkeit halber wird hier ein weiterer Ansatz verwendet, bei dem Java-Streams verwendet werden, um das ursprüngliche Array zu erhalten und ein neues umgekehrtes Array zu erstellen:

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

Mit Guave:

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

Einfach für die Schleife!

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

Das wird dir helfen

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

So würde ich es persönlich lösen. Der Grund für die Erstellung der parametrisierten Methode ist, dass jedes Array sortiert werden kann, nicht nur Ihre Ganzzahlen.

Ich hoffe, dass Sie etwas davon lesen.

@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;
}
4
AnthonyJClink
for(int i=validData.length-1; i>=0; i--){
  System.out.println(validData[i]);
 }
4
Deepak Singh

Im Falle von Java 8 können wir das Integer-Array auch mithilfe von Streams umkehren:

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]
3
i_am_zero

Ihr Programm funktioniert nur für length = 0, 1. Sie können Folgendes versuchen:

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

Wenn Sie mit primitiveren Daten arbeiten (d. H. Char, byte, int usw.), können Sie unterhaltsame XOR - Operationen ausführen.

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];
    }
}
3
AbsoluteBlue
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;
        }
    }
2
amicos

Es ist am effizientesten, das Array einfach rückwärts zu durchlaufen.

Ich bin nicht sicher, ob Aarons Lösung dies für diesen Aufruf bedeutet Collections.reverse(list); Weiß jemand?

2
Nick Strupat

Lösung mit o(n) Zeitkomplexität und o(1) Platzkomplexität.

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

Wäre es für Fehler nicht viel unwahrscheinlicher?

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

nachfolgend finden Sie das vollständige Programm, das auf Ihrem Computer ausgeführt werden kann.

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

Für Programme auf Matrix mit Arrays dies ist die gute Quelle . Gehen Sie durch den Link.

0
Mdhar9e

Folgendes habe ich mir ausgedacht:

// 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
Simple-Solution

Hier ist eine einfache Implementierung, um das Array von jedem Typ , plus full/partial support umzukehren.

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

}

Hier ist der entsprechende Unit-Test 

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
craftsmannadeem

Verwenden Sie die Lösung XOR, um die temporäre Variable zu vermeiden, so sollte Ihr Code aussehen

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

Siehe diesen Link für eine bessere Erklärung:

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

0
vikarjramun

2 Möglichkeiten, ein Array umzukehren.

  1. Verwenden Sie For-Schleife und tauschen Sie die Elemente bis zum Mittelpunkt mit der Zeitkomplexität von 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. Eingebaute Funktion verwenden (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));
    

    }

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

0
Sameer Shrestha
 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);

    }
0
roshan posakya
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
Z A Abbasi

Es gibt zwei Möglichkeiten, um eine Lösung für das Problem zu finden:

1. Umkehren eines Arrays im Raum.

Schritt 1. Tauschen Sie die Elemente am Start- und Endindex aus.

Schritt 2. Erhöhen Sie den Startindex um den Endindex.

Schritt 3. Wiederholen Sie Schritt 1 und Schritt 2 bis zum Startindex <Endindex

Dazu wird die Zeitkomplexität O(n) und die Raumkomplexität O (1) sein.

Beispielcode zum Umkehren eines Arrays im Weltraum sieht wie folgt aus:

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. Umkehren eines Arrays mit einem Hilfsarray.

Schritt 1. Erstellen Sie ein neues Array mit der Größe, die dem angegebenen Array entspricht.

Schritt 2. Fügen Sie Elemente ab dem Startindex in das neue Array ein, beginnend mit dem angegebenen Array

Dazu wird die Zeitkomplexität O(n) und die Raumkomplexität O (n) sein.

Beispielcode zum Umkehren eines Arrays mit Hilfsarray sieht folgendermaßen aus:

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

Wir können dazu auch die Collections API von Java verwenden.  

Die Collections-API verwendet intern denselben umgekehrten Ansatz.

Beispielcode für die Verwendung der Collections-API sieht folgendermaßen aus:

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