编写一个方法，将一维数组向右旋转一个位置，使最后一个元素成为第一个元素。

Question

我认为我混淆了方法，无法正确获取实际方法。请帮忙，数组需要向右旋转，第一个数字将成为最后一个数字。我根据用户输入的大小生成一个随机数组。然后我打印该数组，然后进行旋转，然后打印新数组，最后一个数字在后，最后一个数字在前。

 import java.util.Scanner;
 import java.util.Random;

 public class modOne {

   public static final int MIN = 1;
   public static final int MAX = 15;

   public static void main(String[] args) {

     Scanner input = new Scanner(System.in);
     int arraySize = 0;

     System.out.println("How many arrays to rotate right?");
     int howMany = input.nextInt();

     while(howMany <= 0) {
       System.out.println("ERROR! Should be positive. REENTER: ");
       howMany = input.nextInt();
     }

     while(howMany > 0) {
       System.out.println("Enter array size: ");
       arraySize = input.nextInt();
     }

     int[] a = new int[arraySize];
     int[] b = new int[arraySize];

     getRand(a, MIN, MAX);
     System.out.println("The array before rotation: ");
     printArray(a);
     System.out.println("THe array after rotation: ");
     transArray(a);
     printArray(b);


     System.out.println("Enter array size: ");
     arraySize = input.nextInt();
   }

   public static void getRand (int[] list, int size, int low, int up) {

     Random rand = new Random();
     for(int r = 0; r < size; r++) {
       list[r] = rand.nextInt(up - low + 1) + low;
     }
   }

   public static void printArray(int[] list, int size) {
     for (int r = 0; r < size; r++) {
       System.out.printf("%5d", list[r]); 
       if(r % 6 == 5)
         System.out.println(); 
     }
     System.out.println(); 
    }

   public static void transArray(int[] list, int size) {
     for(int r = 0; r < size - 1; r++) {
       list[r] = list[r-1];
     }
   }
 }

Answer 1

您可以使用System.arrayCopy 将 sourceArray 从起始索引复制到目标数组从起始索引。您还可以指定应复制多少元素作为System.arrayCopy 方法的最后一个参数。见下文：

int[] arr = new int[]{8, 15, 2,10, 11,15,1,3}; 

System.out.println("array before rotation: " + Arrays.toString(arr));

int lastElement = arr[arr.length -1 ];
System.arraycopy(arr, 0, arr, 1, arr.length-1);
arr[0] = lastElement;

System.out.println("array after rotation: " + Arrays.toString(arr));

我备份最后一个元素，然后将数组完全复制到一个新数组中，跳过数组的第一个元素，然后我将数组的第一个元素分配给我早期备份的值。

你得到的输出如下：

array before rotation: [8, 15, 2, 10, 11, 15, 1, 3]
array after rotation: [3, 8, 15, 2, 10, 11, 15, 1]

有关 System.arrayCopy 工作原理的更多详细信息，您可以查看以下tutorial 或阅读我在此question 中的答案。

Answer 2

您只需颠倒顺序并保存您要覆盖的值以便稍后恢复它。我还冒昧地对您的代码进行了一些其他更改。现在它应该可以按预期工作了。

    while (howMany <= 0) {
        System.out.println("ERROR! Should be positive. REENTER: ");
        howMany = input.nextInt();
    }

    System.out.println("Enter array size: ");
    arraySize = input.nextInt();

    int[] a = new int[arraySize];
    int[] b = new int[arraySize];

    getRand(a, MIN, MAX);
    System.out.println("The array before rotation: ");
    printArray(a);
    System.out.println("THe array after rotation: ");
    printArray(transArray(a));

}

public static void getRand(int[] list, int low, int up) {

    Random rand = new Random();
    for (int r = 0; r < list.length; r++) {
        list[r] = rand.nextInt(up - low + 1) + low;
    }
}

public static void printArray(int[] list) {
    for (int r = 0; r < list.length; r++) {
        System.out.printf("%5d", list[r]);
        if (r % 6 == 5) {
            System.out.println();
        }
    }
    System.out.println();
}

public static int[] transArray(int[] list) {

    int temp1 = list[list.length - 1];

    for (int r = list.length - 1; r >  0; r--) {
        list[r] = list[r-1];
    }

    list[0] = temp1;

    return list;
}

Answer 3

您可以使用Arrays.copyOfRange(T[] original, int from, int to) 来移动大部分数组。不过，有些数字已被截断，之后需要重新输入。

public static void main( String[] args ) {
    int[] arr = { 1, 2, 3, 4, 5, 6 };
    arr = rot(arr, -1);
    System.out.println(Arrays.asList(arr));
}


public static int[] rot( int[] arr, int amt ) {
    while ( amt < 0 )
        amt += arr.length;
    amt = amt % arr.length;
    int[] k = Arrays.copyOfRange(arr, amt, arr.length + amt);
    for ( int i = 0; i < amt; i++ )
        k[k.length - amt + i] = arr[i];
    return k;
}

rot() 向左旋转amt，因此使用参数 amt = -1 可以实现您的目标。

rot() 方法首先强制使用0 ≤ amt < arr.length。这是因为一旦你旋转了数组的全长，你就回到了你开始的地方。接下来，它将数组移动 amt，将整数的默认值 (0) 添加到末尾作为填充以保留长度。最后，它将丢失的元素添加回放置 0 的数组中。

Answer 4

for(int i = 0; i < validData.length / 2; i++)
{
    int temp = validData[i];
    validData[i] = validData[validData.length - i - 1];
    validData[validData.length - i - 1] = temp;
}

这背后的逻辑是你交换值直到你到达中心：

我制作这张图片是为了让您更好地理解

这里没有中心，但是如果有3.5，那么它会忽略三点五，因为validData[validData.length - i - 1] = temp;