Обратный массив в Java

Я пытаюсь повернуть массив двумя способами:

1) Создав новый массив, который был очень простым:

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

2) Второй метод, я получил свой ответ, но я на самом деле неЯ не очень хорошо это понимаю, он на самом деле использует подкачку, присваивая значение массива временной переменной, затем изменяет его и возвращает исходную переменную:

public static int[] reverse2(int[] array)
{
    for (int i=0; i < array.length / 2; i++)
    {   
        int temp = array[i];
        array[i] = array[array.length - i - 1];
        array[array.length - i - 1] = temp;
    }
    return array;
}

Может ли кто-нибудь объяснить мне второй код? Я нене понимаю деление на 2? Что произойдет, если размер массива будет четным или нечетным?

Ответы на вопрос(6)

Массив делится на два, потому что вы поменяете местами 0 и n, 1 и n-1 и т. Д. Если массив имеет нечетное количество значений, последнее значение должно быть непосредственно в центре массива и не нужно будет поменяться местами. Мы можем зациклить размер массива, деленный на n, потому что требуется только n / 2 перестановки.

 adchilds20 нояб. 2012 г., 02:44
Похоже, awolfe91 победил меня в этом.

Представьте, что ваш массив это:

[ 1 2 3 4 5 ]

Второе решение, которое выМы разместили работы следующим образом:

[ 1 2 3 4 5 ]
  ^--swap-^

[ 5 2 3 4 1 ]
    ^swp^

[ 5 4 3 2 1 ]

Как видите, вам нужно только пройтиполовина массива, чтобы это работало (следовательно, оно работает лучше, чем первое решение, где вам нужно пройти через все это). Это где деление на два приходит;половина массива приравнивается только к необходимости проверять элементы до.array.length / 2

Для четного числа элементов он будет делать то же самое, только поменяв местами самую внутреннюю пару:

[ 1 2 3 4 5 6 ]
  ^--swap---^

[ 6 2 3 4 5 1 ]
    ^swap-^

[ 6 5 3 4 2 1 ]
      ^-^

[ 6 5 4 3 2 1 ]
Решение Вопроса

Деление на 2 просто так, что вы проходите только первую половину массива. Если вы поменяете местами первый и последний элементы, вы неЯ не хочу делать это снова, когда я достигну array.length. Если размер четный, он остановится перед второй половиной, если размер нечетный, он остановится перед центральной позицией, которая нев любом случае не нужно переключаться. Надеюсь, это поможет!

Делим на 2 вонне работает полностью. Это будет работать только если у вас есть нечетное число целых чисел.

Например:

Дайте мне целое число, которое будет представлять длину массива: 5

Введите 5 значений

Значение № 0: 1

Значение №1: 2

Значение № 2: 3

Значение № 3: 4

Значение № 4: 5

Ваш текущий массив: 1 | 2 | 3 | 4 | 5 |

Ваш массив перевернут: 5 | 4 | 3 | 2 | 1 | СТРОИТЬ УСПЕШНО (общее время: 11 секунд)

Теперь, если вы должны положить четное число целых чисел, давайтескажем 6, вот что произойдет:

Дайте мне целое число, которое будет представлять длину массива: 6

Введите 6 значений

Значение № 0: 1

Значение №1: 2

Значение № 2: 3

Значение № 3: 4

Значение № 4: 5

Значение № 5: 6

Ваш текущий массив: 1 | 2 | 3 | 4 | 5 | 6 |

Ваш массив полностью изменен: 6 | 5 | 3 | 4 | 2 | 1 | СТРОИТЬ УСПЕШНО (общее время: 5 секунд)

Исходный код:

/ * Напишите программу, которая запрашивает у пользователя целое число, которое будет представлять длину массива, а затем просит пользователя ввести такое количество значений. Сохраните эти значения в массиве и напечатайте массив. Затем переверните элементы массива так, чтобы первый элемент стал последним элементом, второй элемент стал вторым по последнему элементу и т. Д., Причем старый последний элемент теперь стал первым. Не просто измените порядок, в котором они напечатаны; на самом деле изменить способ, которым они хранятся в массиве. Не создавайте второй массив; просто переставьте элементы в вашем массиве. (Подсказка: поменяйте местами элементы, которые нужно поменять местами.) Когда элементы поменялись местами, снова распечатайте массив. * /

пакет реверсинганаррей;

импорт java.util.Scanner;

открытый класс ReversinganArray {}

public static void main(String[] args) {
    int i = 0;
    Scanner input = new Scanner(System.in);
    System.out.print("Give me an integer that would represent the length of an array: ");
    int integer = input.nextInt();
    int[] test = new int[integer];
    System.out.println("Enter " + integer + " " + "value(s)");
    while (i < integer) {
        System.out.println("Value #" + i + ": ");
        test[i] = input.nextInt();
        i++;
    }
    System.out.print("Your current array: ");
    i = 0;
    while (i < integer) {
        System.out.print(test[i] + " | ");
        i++;
    }
    i = ,0;
    while (i 
 jogojapan02 мар. 2014 г., 03:14
В вашем коде у вас естьi
 user336899602 мар. 2014 г., 21:20
Я нашел другой способ, как это сделать. Вместо меня целое число / 2 вы можете просто сделать я < целое число - я. Я думаю, что мы оба были не правы, ха-ха

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

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

Цикл по-прежнему работает нормально, независимо от того, является ли количество элементов в массиве нечетным или четным. Если количество элементов нечетное, цикл останавливается перед средним элементом.

 neilvillareal20 нояб. 2012 г., 02:46
Похоже, 3 других уже ответили, пока я набирал ответ :)

Просто и быстро ...

public class ReverseAnIntegerArray {
static void reverseAnArray(int[] arrNum) {
    System.out.println("Original Array :" + Arrays.toString(arrNum));

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

}

public static void main(String[] args) {
    int myArr[] = { 1, 2, -3, 4, 5, 34, 50 };
    reverseAnArray(myArr);
}

}

Out out будет - Original Array: [1, 2, -3, 4, 5, 34, 50]

50 34 5 4 -3 2 1

Ваш ответ на вопрос