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

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;

Answer 3

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

    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 4

您可以使用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的数组中。

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

4 个答案: