Question

CodingBat > Java > Array-1 > reverse3：

给定一个整数长度为3的数组，返回一个新元素，其元素的顺序相反，因此{1,2,3}变为{3,2,1}。

public int[] reverse3(int[] nums) {
    int[] values = new int[3];
    for (int i = 0; i <= nums.length - 1; i++) {
        for (int j = nums.length-1; j >= 0; j--) {
            values[i] = nums[j];
        }
    }
    return values;
}

我无法使其正常工作，通常是数组中的最后一个int，成为新数组中的每个int

Answer 1

除非这是作业，否则为什么不使用Apache ArrayUtils'

ArrayUtils.reverse(nums)

永远不要重新发明轮子：）

Answer 2

您不需要两级循环。只需要一个循环：

for(int i = 0, j = nums.length - 1; i < nums.length; i++,j--) {
    values[i] = nums[j];
}

或者，或者，不要单独跟踪j，并执行此操作：

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

Answer 3

首先，在创建新数组时，给它大小的旧数组。接下来，当你正在反转一个数组时，你不需要两个循环，只需要一个：

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

Answer 4

输入int[]的长度固定为3？然后它没有比这简单。

public int[] reverse3(int[] nums) {
    return new int[] { nums[2], nums[1], nums[0] };
}

另见：

CodingBat/Java/Array-1/reverse3
- 请注意Array-1是“基本数组问题 - 没有循环”。如果你愿意，可以使用循环，但设计不能使用循环解决。

Answer 5

你只想要一个循环，但索引是双向的：

public int[] reverse(int[] nums) {
    int[] back = new int[nums.length];
    int i,j;
    for (i=0,j=nums.length-1 ; i<nums.length ; i++,j--)
        back[i] = nums[j];
    return back;
}

Answer 6

public int[] reverse3(int[] nums) {
 int rotate[]={nums[2],nums[1],nums[0]};
 return rotate;
}

Answer 7

此代码给出正确的输出：-

public int[] reverse3(int[] nums) {
  int[] myArray=new int[3];
  myArray[0]=nums[2];
  myArray[1]=nums[1];
  myArray[2]=nums[0];
  return myArray;
}

Answer 8

  public int[] reverse3(int[] nums) {
  int[] values = new int[nums.length];
  for(int i=0; i<nums.length; i++) {
   values[nums.length  - (i + 1)]=nums[i];
  }
  return values;
  }

Answer 9

在你的代码中，对于i的每个值，你将i处的目标数组元素设置为j中的“nums”值。这就是你在所有迭代结束时为所有元素得到相同值的方法。首先，对于简单的交换算法有两个循环非常糟糕的逻辑，例如：

public static void reverse(int[] b) {
   int left  = 0;          // index of leftmost element
   int right = b.length-1; // index of rightmost element

   while (left < right) {
      // exchange the left and right elements
      int temp = b[left]; 
      b[left]  = b[right]; 
      b[right] = temp;

      // move the bounds toward the center
      left++;
      right--;
   }
}//endmethod reverse

或简化：

for (int left=0, int right=b.length-1; left<right; left++, right--) {
    // exchange the first and last
    int temp = b[left]; b[left]  = b[right]; b[right] = temp;
}

为什么要经历所有这些痛苦，为什么你不相信Java的内置API并做类似的事情

public static Object[] reverse(Object[] array)
{
List<Object> list = Arrays.asList(array);
Collections.reverse(list);
return list.toArray();
}

创建一个新的反向Java数组

9 个答案:

另见：