Hoe kan ik een int-array in Java omkeren?

Ik probeer een int-array in Java om te draaien.

Deze methode keert de array niet om.

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

Wat is er mis mee?


Antwoord 1, autoriteit 100%

Om een ​​int-array om te keren, verwissel je items tot je het middelpunt bereikt, zoals dit:

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

Zoals je het doet, verwissel je elk element twee keer, dus het resultaat is hetzelfde als de eerste lijst.


Antwoord 2, autoriteit 91%

Met Commons.Lang kun je gewoon

gebruiken

ArrayUtils.reverse(int[] array)

Meestal is het sneller en veiliger om vast te houden aan gemakkelijk beschikbare bibliotheken die al door de unit zijn getest en door de gebruiker zijn getest wanneer ze uw probleem oplossen.


Antwoord 3, autoriteit 22%

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

java.util.Collections.reverse() kan java.util.Lists en java.util.Arrays.asList() retourneert een lijst die de specifieke array omhult die u eraan doorgeeft, daarom wordt yourArray omgekeerd na het aanroepen van Collections.reverse().

De kosten zijn slechts het maken van één List-object en er zijn geen extra bibliotheken nodig.

Een soortgelijke oplossing is gepresenteerd in het antwoord van Tarik en hun commentatoren, maar ik denk dat dit antwoord beknopter en gemakkelijker te parseren zou zijn.


Antwoord 4, autoriteit 18%

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

Antwoord 5, autoriteit 14%

Ik denk dat het een beetje makkelijker is om de logica van het algoritme te volgen als je expliciete variabelen declareert om de indices bij te houden die je verwisselt bij elke iteratie van de lus.

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

Ik denk ook dat het beter leesbaar is om dit in een while-lus te doen.

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

Antwoord 6, autoriteit 5%

Er zijn hier al veel antwoorden, vooral gericht op het ter plekke aanpassen van de array. Maar voor de volledigheid is hier een andere benadering waarbij Java-streams worden gebruikt om de originele array te behouden en een nieuwe omgekeerde array te maken:

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

Antwoord 7, autoriteit 4%

Met guave:

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

Antwoord 8, autoriteit 4%

In het geval van Java 8 kunnen we ook IntStream gebruiken om de reeks gehele getallen om te keren als:

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]

Antwoord 9, autoriteit 3%

Eenvoudig voor lus!

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

Antwoord 10, autoriteit 2%

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

Antwoord 11, autoriteit 2%

Dit zal je helpen

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

Antwoord 12, autoriteit 2%

Zo zou ik het persoonlijk oplossen. De reden achter het maken van de geparametriseerde methode is dat elke array kan worden gesorteerd… niet alleen uw gehele getallen.

Ik hoop dat je er iets van opsteekt.

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

Antwoord 13, autoriteit 2%

Als je werkt met gegevens die primitiever zijn (d.w.z. char, byte, int, enz.), dan kun je wat leuke XOR-bewerkingen doen.

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

Antwoord 14

Je programma werkt alleen voor length = 0, 1.
Je kunt proberen:

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

Antwoord 15

Er zijn hierboven enkele geweldige antwoorden, maar dit is hoe ik het deed:

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

Antwoord 16

Het is het meest efficiënt om de array gewoon achteruit te herhalen.

Ik weet niet zeker of Aarons oplossing dit doet via deze oproep Collections.reverse(list); Weet iemand dat?


Antwoord 17

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

Antwoord 18

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

Antwoord 19

Zou het op deze manier niet veel onwaarschijnlijker zijn voor fouten?

    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;

Antwoord 20

Oplossing met o(n) tijdcomplexiteit en o(1) ruimtecomplexiteit.

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

Antwoord 21

Er zijn twee manieren om een ​​oplossing voor het probleem te vinden:

1. Keer een array om in de ruimte.

Stap 1. Verwissel de elementen aan de begin- en eindindex.

Stap 2. Verhoog de startindex en verlaag de eindindex.

Stap 3. Herhaal stap 1 en stap 2 tot startindex < eindindex

Hiervoor is de tijdscomplexiteit O(n) en de ruimtecomplexiteit O(1)

Voorbeeldcode voor het omkeren van een array in de ruimte is als volgt:

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. Keer een array om met een hulparray.

Stap 1. Maak een nieuwe array met een grootte gelijk aan de opgegeven array.

Stap 2. Voeg elementen in de nieuwe array in, beginnend bij de startindex, vanaf de
gegeven array beginnend bij eindindex.

Hiervoor is de tijdscomplexiteit O(n) en de ruimtecomplexiteit O(n)

Voorbeeldcode voor het omkeren van een array met hulparray is als volgt:

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

We kunnen hiervoor ook de Collections API van Java gebruiken.

De Collections API gebruikt intern dezelfde omgekeerde benadering in de ruimte.

Voorbeeldcode voor het gebruik van de Collections API is als volgt:

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

Antwoord 22

2 manieren om een ​​array om te keren .

  1. Gebruik de For-lus en verwissel de elementen tot het middelpunt met een tijdcomplexiteit van 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. Geïntegreerde functie gebruiken (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));
    

    }

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


Antwoord 23

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

Antwoord 24

Hieronder staat het volledige programma dat op uw computer kan worden uitgevoerd.

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

Voor programma’s op matrix die arrays gebruiken is dit de goede bron. Ga door de link.


Antwoord 25

Gebruik de XOR-oplossing om de tijdelijke variabele te vermijden waar uw code eruit zou moeten zien

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

Zie deze link voor een betere uitleg:

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


Antwoord 26

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

Antwoord 27

Hier is een eenvoudige implementatie, om arrays van elk type om te keren, plus volledige/gedeeltelijke ondersteuning.

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 is de bijbehorende 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));
 }
}

Antwoord 28

Dit is wat ik heb bedacht:

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

Antwoord 29

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

Antwoord 30

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

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes