Question

我正在学习数组，我试图颠倒数组中的顺序。这是我迄今为止所获得的方法，但它仅适用于数组中前半部分的值。我做错了什么？

public static void reverse(int[] anArray)
{
    int[] a = anArray ;
    for (int j = 0; j <= (a.length - 1); j++ )
    {
        anArray[j] = a[(anArray.length - j - 1)];
    }
}

Answer 1

您需要创建一个临时位置才能进行交换。此代码将数组的末尾写入前面，但是当您编写数组的末尾时，前半部分的值已经丢失。

public static void reverse(int[] a)
{
    int l = a.length;
    for (int j = 0; j < l / 2; j++)
    {
        int temp = a[j];
        a[j] = a[l - j - 1];
        a[l - j - 1] = temp;
    }
}

此外，您正在增加j两次。 for循环定义的最后一部分执行每个循环之间的增量。您无需在循环块内手动执行此操作。

Answer 2

这不是一个难题，对不起，你已经收到了几个错误的答案。

您的目标是撤消现有阵列的内容。您的想法是从相应的数组索引分配每个数组索引，以便全部切换它们。但是，这只有在所有分配同时发生时才有效。代码实际上一次运行一个赋值。因此，当你到达数组的后半部分时，你正在复制的索引已经被先前的循环运行所改变。

要解决此问题，您需要交换索引对。循环到中途（因为否则你将交换每对两次，并最终到达你开始的地方）;取两个指数并交换它们。现在，由于我们刚刚讨论过的原因，你不能只将一个分配给另一个，反之亦然。相反，您需要首先“记住”变量中的一个值。从另一个索引中分配到该索引（因为您保存了旧值），然后最终将记住的值分配给另一个索引。

Answer 3

public static void swap (int[] a, int pos1, int pos2)
{
      int tmp = pos1;
      a[pos1] = a[pos2];
      a[pos2] = tmp;
}

public static void reverse (int[] a)
{
    int l = a.length;
    for (int j = 0; j < (l / 2); j++)
    {
        swap (a, j, l - j - 1);
    }
}

变量l只是为了简洁 - 它不是推荐。

数组内容在Java中是可变的，因此您不需要第二个，这只是对同一个数组的新引用。

对不起 - 我当然错过了交换。

Answer 4

当你写int[] a = anArray时，它不是数组的副本，而是对同一个数组的引用。这就是为什么它只适用于数组的前半部分，因为数据的后半部分第一部分已被覆盖。要解决这个问题，你必须写：

int[] a = anArray.clone();

Answer 5

如果你能够使用整数数组，你可以这样做：

    Integer[] anArray = {0,2,4,1}; // an array of Integer because List do not accept int as type.

    List<Integer> list = Arrays.asList(anArray);  // converting the array to List

    Collections.reverse(list); // reversing the "list" variable.

您还可以使用Guava的Lists.reverse(List)创建由给定列表支持的视图，该列表的顺序相反，无需复制或修改原始列表。

Answer 6

这通过就地技术反转源阵列。基本上，您只能使用源数组，不能创建另一个。

public static void reverseArrayInPlace(int [] source){
    for(int col=0; col<source.length/2; ++col){         
        int temp=source[col];
        source[col]=source[(source.length-1)-col];
        source[(source.length-1)-col]=temp;
    }
}

//最初; 10 20 30 40 50 60

// col = 0; 60 20 30 40 50 10

// col = 1; 60 50 30 40 20 10

// col = 2; 60 50 40 30 20 10

// col = 3; 60 50 30 40 20 10

// col = 4; 60 20 30 40 50 10

// col = 5; 10 20 30 40 50 60

这就是为什么我们给出条件col<(source.length/2)，如果它达到col<source.length那么它将以与之前相同的方式排列，即它不会反转。尝试两种方式自己看看。

Answer 7

public static void reverse(int[] anArray)
{
 int[] newArray = new int[anArray.length];
 int index = 0;
 for (int b = anArray.length - 1; b >= 0; b++)
 {
  newArray[index] = anArray[b];
  index++;
 }
}

从0开始索引，并从“anArray”中取出最后一个元素并将其放在newArray中的索引处;

Answer 8

以下是使用堆栈进行反转的经典示例！

public static void main(String[] args) {
    int[] myIntArray = { 10, 20, 30, 40, 50, 60 };
    int [] reversedArray= new int[myIntArray.length];
    int reversedPosition=0;
    Stack<Integer> s = new Stack<>();
    for (int integer : myIntArray)
        s.push(integer);
    while (!s.empty()) {
        reversedArray[reversedPosition]=s.pop();
        reversedPosition++;
    }
}

Answer 9

您的问题是您正在从正在修改的同一个数组中读取值。

public static void reverse(int[] originalArray) {
    int[] newArray = new int[originalArray.length];

    for (int i = 0; i < originalArray.length; i++) {
        newArray[i] = originalArray[originalArray.length - i - 1];
    }
}

Java数组顺序反转

9 个答案: