Как поместить массив в обратном порядке? [dубликат]

Если вы работаете с более примитивными данными (т. е. char, byte, int и т. д.), вы можете делать некоторые интересные операции XOR.

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

Вот как я лично ее разрешу. Причина создания параметризованного метода заключается в том, чтобы разрешить сортировку любого массива ... не только ваши целые числа.

Надеюсь, вы что-то извлекли из него.

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

public static <T> T[] reverse(T[] arrayToReverse){
   //as per the collections spec (and pointed out by @Radiodef)
   // the collections api will sort the array in place.
   Collections.reverse(Arrays.asList(arrayToReverse));
   return arrayToReverse;
}

Я думаю, что немного легче следовать логике алгоритма, если вы объявляете явные переменные для отслеживания индексов, которые вы обмениваете на каждой итерации цикла.

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

Я также думаю, что это более читаемо для этого в цикле while.

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

Вот простая реализация, обратная матрица любого типа плюс полная / частичная поддержка.

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

}

Вот соответствующий модульный тест

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

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

java.util.Collections.reverse() может отменить java.util.List s, а java.util.Arrays.asList() возвращает список, который обертывает конкретный массив, который вы передаете ему, поэтому yourArray отменяется после вызова Collections.reverse().

Стоимость - это просто создание одного объекта List и никаких дополнительных библиотек не требуется.

Аналогичное решение было представлено в ответе Тарика и их комментаторов, но я думаю, что этот ответ будет быть более кратким и более легко разбираемым.

Ваша программа будет работать только для length = 0, 1. Вы можете попробовать:

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

Это работает, если вы хотите вернуться, пока не дойдете до середины массива?

    double [] list = {11,21,31,41,51,61,71,81,91};
    int midpoint = list.length/2 -1;
    int firstVal = 0;
    while(firstVal < midpoint){
        double midPoint = list[midpoint];
        double firstValue = list[firstVal];
        list[midpoint] = firstValue;
        list[firstVal] = midPoint;

        firstVal = firstVal + 1;
        midpoint = midpoint-1;
    }
    StdOut.println(Arrays.toString(list));
}

Вот простое быстрое решение. Надеюсь, это поможет!

public int[] reverse(int[] arr) {
    for(int i = arr.length; i > 0 ; i--){
        System.out.print(arr[i-1] + " ");
    }
    return arr;
}

В случае Java 8 мы также можем использовать потоки для обращения к целочисленному массиву как:

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]

С Commons.Lang вы могли бы просто использовать

ArrayUtils.reverse(int[] array)

. В большинстве случаев быстрее и безопаснее использовать легкодоступные библиотеки, которые уже тестировались и тестировались пользователем, когда они позаботьтесь о своей проблеме.

Другой способ обращения к массиву

public static int []reversing(int[] array){
    int arraysize = array.length;
    int[] reverse = new int [arraysize+1];
    for(int i=1; i <= arraysize ; i++){
        int dec= arraysize -i;
        reverse[i] = array[dec];
    }
    return reverse;
}

Поскольку я намеревался сохранить свой первоначальный массив, я решил эту проблему следующим образом:

List<Integer> normalArray= new ArrayList<>();
List<Integer> reversedArray = new ArrayList<>();

// Fill up array here

for (int i = 1; i <= normalArray.size(); i++) {
  reversedArray .add(normalArray.get(normalArray.size()-i));
}

Итак, в основном, цикл через начальный массив и добавьте все значения в обратном порядке, чтобы новый (обратный) массив. Тип списка может быть любым. Я много раз работаю над этим кодом, поэтому некоторые другие решения не работают.

ниже - полная программа для запуска на вашем компьютере.

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

Для программ на матрице с использованием массивов это будет хороший источник. По ссылке.

Не будет ли это делать так мало вероятным для ошибок?

    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;

Лучше всего просто перебрать массив назад.

Я не уверен, что решение Aaron делает это vi этим вызовом Collections.reverse(list); Кто-нибудь знает?

Здесь уже много ответов, в основном сосредоточено на изменении массива на месте. Но для полноты, вот еще один подход с использованием потоков Java для сохранения исходного массива и создания нового реверсивного массива:

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

Попробуйте этот код:

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

Простой для цикла!

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

Решение с o (n) временной сложностью и o (1) сложностью пространства.

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

Используя решение XOR, чтобы избежать временной переменной, ваш код должен выглядеть так:

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

См. эту ссылку для лучшего объяснения:

http://betterexplained.com/ статьи / своп-две переменных-используя-исключающий /

С Guava:

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

Это поможет вам

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