Question

我想将一个数组从0翻转到索引n，所有翻转的元素都应该反转。

如果我打电话翻转（A，2）我希望的结果是

true, false, true , true, false

（数组部分从0到2向后选择，值反转）

public class test{

public static void main(String[] args) {
    Boolean[] A = { false, true, false, true, false };

    A = Flip(A, 4);

    print(A);
}

public static Boolean[] Flip(Boolean[] A, int n) {
    Boolean[] Atemp = A;

    for (int i = 0; i <= n; i++) {
        Atemp[i] = !A[n - i];
    }

    return Atemp;
}

public static void print(Boolean[] A) {
    for (Boolean b : A)
        System.out.println("" + b);

    System.out.println();
}

}

但我得到的结果是

true,false,false,true,false

是我的代码中的错误（最有可能）或者是否涉及Java特定的故障。

感谢您的帮助

Answer 1

首先，您可以使用boolean[]（不需要Boolean[]）。其次，当您将引用从A分配给Atemp时，您不会复制数组（您将引用的值传递给函数）。您需要从0 < n进行迭代并在每个索引处翻转数组（而不是对齐偏移量）。最后，Java命名约定将使用flip（因为Flip看起来像一个类名。）

public static void flip(boolean[] arr, int n) {
    for (int i = 0; i < n; i++) {
        arr[i] = !arr[i];
    }
}

然后您可以将其称为

public static void main(String[] args) {
    boolean[] arr = { false, true, false, true, false };
    flip(arr, 4);
    System.out.println(Arrays.toString(arr));
}

我得到（根据要求）

[true, false, true, false, false]

Answer 2

您的代码存在一些问题：

它不会翻转数组，但也会反转它。猜猜这只是规范中的一个错误。
您的代码尝试就地反转数组，但未正确实现。
您的代码的n为包含上限，但规范声明它应该是独占的。

关于第1点：假设这只是规范的一个问题，我们可以忽略这一点。

第3点：只需从

for (int i = 0; i <= n; i++)

到

for (int i = 0; i < n; i++)

获得理想的行为。

第2点：
在这里，我们可以采取几种方法：实际实施就地反演：

public static Boolean[] Flip(Boolean[] A, int n) {
    for (int i = 0; i < n / 2.0; i++) {
        boolean tmp = A[i];
        A[i] = !A[n - i - 1];
        A[n - i - 1] = !tmp;
    }

    return A;
}

或者创建数组的副本并在该副本内反转：

public static Boolean[] Flip(Boolean[] A, int n) {
    Boolean[] Atemp = Arrays.copyOf(A , A.length);

    for (int i = 0; i < n; i++) {
        Atemp[i] = !A[n - i - 1];
    }

    return Atemp;
}

并且无需使用Boolean[]。只需使用原始类型boolean[]。

未来的提示：实际上可以使用调试器进行调试，或者如果您愿意，只需更改代码以反转int[]而不是boolean[]。只需使用{1, 2, 3, 4, 5, ...}，单个元素会发生什么变得非常明显。

翻转阵列部分

2 个答案: