1

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

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

4

6 回答 6

9

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

于 2012-11-20T01:43:17.933 回答
7

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

[ 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 ]
于 2012-11-20T01:44:06.000 回答
2

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

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

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

于 2012-11-20T01:45:36.367 回答
1

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

于 2012-11-20T01:44:18.487 回答
0

简单快速...

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

于 2018-08-18T18:52:13.530 回答
-2

除以 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 <= 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++;
    }
}

}

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

于 2014-03-01T18:41:43.243 回答