Question

我试图以两种方式反转数组：

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？如果数组大小是偶数还是奇数会发生什么？

Answer 1

除以2只是为了让你只通过数组的前半部分。如果你交换第一个和最后一个项目，当我到达array.length时你不想再这样做。如果尺寸是均匀的，它将在下半部分之前停止，如果尺寸是奇数，它将在中心位置之前停止，无论如何都不需要切换。希望有所帮助！

Answer 2

想象一下你的数组是这样的：

[ 1 2 3 4 5 ]

您发布的第二个解决方案如下：

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

[ 5 2 3 4 1 ]
    ^swp^

[ 5 4 3 2 1 ]

正如您所看到的，您只需遍历数组的 half 就可以使其工作（因此它的性能优于第一个解决方案，您需要遍历整个事物）。这是两个分裂的地方;数组的 half 等于只需要检查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 ]

Answer 3

除以2意味着您不必遍历数组中的所有元素。由于您正在反转数组，而循环位于第一个元素，这意味着它应该只是将它与另一端的第一个元素交换。

基本上除以2只是为了减少循环的遍数。将其视为性能增强。

无论数组中的元素数是奇数还是偶数，循环仍然可以正常工作。如果元素的数量是奇数，则循环在中间元素之前停止。

Answer 4

数组除以2，因为你将交换位置0和n，1和n-1等。如果数组有一个奇数的值，最后一个值应该直接在数组的中心，并将不需要交换。我们可以遍历数组大小除以n，因为只需要发生n / 2次交换。

Answer 5

简单快捷...

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

}

输出将是- 原始数组：[1、2，-3、4、5、34、50]

50 34 5 4 -3 2 1

Answer 6

除以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秒）

源代码：

/ * 编写一个程序，提示用户输入一个表示数组长度的整数，然后要求用户输入那么多值。将这些值存储在数组中并打印数组。然后反转数组元素，使第一个元素成为最后一个元素，第二个元素成为倒数第二个元素，依此类推，现在是旧的最后一个元素。不要只是颠倒它们的印刷顺序;实际上改变了它们存储在数组中的方式。不要创建第二个数组;只需重新排列阵列中的元素即可。（提示：交换需要更改位置的元素。）反转元素后，再次打印数组。 * /

package reversinganarray;

import 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 <= integer / 2) {
        int temp = test[i]; //a = b
        test[i] = test[(integer - i - 1)]; //b = c
        test[(integer - i - 1)] = temp;// c = a
        i++;
    }
    System.out.println("");
    System.out.print("Your array reversed: ");
    i = 0;
    while (i <= integer - 1) {
        System.out.print(test[i] + " | ");
        i++;
    }
}

}

我碰巧试图自己解决这个问题......

在Java中反转数组

6 个答案: