数组以相反的顺序[重复]

Question

我有一个包含 n 个元素的数组和这些方法：

• last()返回数组的最后一个int
• first() 返回数组的第一个 int
• size()返回数组长度
• replaceFirst(num) 在开头添加 int 并返回其位置
• remove(pos) 删除 pos 处的 int

我必须创建一个以相反顺序为我提供数组的新方法。 我需要使用那些方法。现在，我不明白为什么我的方法不起作用。 所以 对于 (int i = 1; 我

remove 会移除位置 i 的元素，并返回它在该位置的数字，然后用 replaceFirst 将移动数组的数字（由 remove 返回）。

我尝试了一个包含 {2,4,6,8,10,12} 的简单数组 我的输出是：12 12 12 8 6 10

所以如果我有一个包含 1,2,3,4,5 的数组

• 对于 i = 1;我要：2,1,3,4,5
• 对于 i=2 >3,2,1,4,5
• 等

但它似乎不起作用。

Answer 1

好吧，我会给你一些提示。有多种方法可以反转数组。

• 最简单和最明显的方法是以相反的顺序循环遍历数组，然后以正确的顺序将值分配给另一个数组。
• 之前的方法需要你使用一个额外的数组，如果你不想这样做，你可以在for循环中有两个索引，一个来自第一个，下一个来自最后一个，然后开始交换这些指数的值。
• 您的方法也可以，但是由于您将值插入到数组的前面，所以它会有点复杂。
• Collections 类中还有一个 Collections.reverse 方法可以反转对象数组。您可以在this post 中了解它

Answer 2

这是放在 Stackoverflow by @unholysampler 上的代码。您可能想从那里开始：Java array order reversing

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

Answer 3

int[] reverse(int[] a) {
    int len = a.length;
    int[] result = new int[len];
    for (int i = len; i > 0 ; i--)
        result[len-i] = a[i-1];
    return result;
}

Answer 4

for(int i = array.length; i >= 0; i--){
    System.out.printf("%d\n",array[i]);
}

试试这个。

Answer 5

如果它是 Java 数组而不是复杂类型，最简单和最安全的方法是使用库，例如阿帕奇共享：ArrayUtils.reverse(array);

Answer 6

在 Java 中用于随机数组：

public static void reverse(){

    int[] a = new int[4];

    a[0] = 3;
    a[1] = 2;
    a[2] = 5;
    a[3] = 1;

    LinkedList<Integer> b = new LinkedList<Integer>();

    for(int i = a.length-1; i >= 0; i--){

        b.add(a[i]); 

    }

    for(int i=0; i<b.size(); i++){

        a[i] = b.get(i);
        System.out.print(a[i] + ",");   
    }



}

希望这会有所帮助。

Answer 7

反转数组是一个相对简单的过程。让我们从思考如何正常打印数组开始。

int[] numbers = {1,2,3,4,5,6};

for(int x = 0; x < numbers.length; x++)
{
    System.out.println(numbers[x]);
}

这是做什么的？嗯，它增加了x，而它小于numbers.length，所以实际发生的是..

第一次运行：X = 0

System.out.println(numbers[x]);
// Which is equivalent to..
System.out.println(numbers[0]);
// Which resolves to..
System.out.println(1);

第二次运行：X = 1

System.out.println(numbers[x]);
// Which is equivalent to..
System.out.println(numbers[1]);
// Which resolves to..
System.out.println(2);    

您需要做的是从numbers.length - 1 开始，然后返回到0。为此，您需要重组您的for loop，以匹配以下伪代码..

for(x := numbers.length to 0) {
    print numbers[x]
}

现在您已经确定了如何打印，是时候开始反转数组了。使用 for 循环，您可以从头到尾循环遍历数组中的每个值。您还需要一个新数组。

int[] revNumbers = new int[numbers.length];

for(int x = numbers.length - 1 to 0) {
    revNumbers[(numbers.length - 1) - x] = numbers[x];
}

Answer 8

int[] noArray = {1,2,3,4,5,6};
    int lenght = noArray.length - 1;

    for(int x = lenght ;  x >= 0; x--)
    {
        System.out.println(noArray[x]);
    }
}

Answer 9

    int[] numbers = {1,2,3,4,5};
    int[] ReverseNumbers = new int[numbers.Length];

    for(int a=0; a<numbers.Length; a++)
    {
        ReverseNumbers[a] = numbers.Length - a;
    }

    for(int a=0; a<ReverseNumbers.Length; a++)
    Console.Write(" " + ReverseNumbers[a]);

Answer 10

int[] numbers = { 1, 2, 3, 4, 5, 6 };
reverse(numbers, 1); >2,1,3,4,5
reverse(numbers, 2); >3,2,1,4,5

public int[] reverse(int[] numbers, int value) {
int index = 0;
for (int i = 0; i < numbers.length; i++) {
  int j = numbers[i];
  if (j == value) {
    index = i;
    break;
  }
}
int i = 0;
int[] result = new int[numbers.length];
int forIndex = index + 1;
for (int x = index + 2; x > 0; x--) {
  result[i] = numbers[forIndex--];
  ++i;
}
for (int x = index + 2; x < numbers.length; x++) {
  result[i] = numbers[x];
  ++i;
}
return result;
}