最直接的方法是找到最小值及其位置，然后旋转，使值位于位置0。找到最小位置是在线性时间内完成的。长杆是旋转。对于单向旋转，将需要N旋转，其中N是lowest value的position。使用另一个数组可以加快这个过程，但由于这是不允许的，提供left和right旋转方法可以最大限度地减少所需的旋转。如果最小单元格超出中间，则向右旋转。否则，向左旋转。

int[] arr = {8, 5, 6, 2, 1, -1, -100, 425, 84};
System.out.println(Arrays.toString(rotateToMin(arr)));
System.out.println(Arrays.toString(rotateToMin(new int[] {3,2,1})));
System.out.println(Arrays.toString(rotateToMin(new int[] {1,2,3})));
System.out.println(Arrays.toString(rotateToMin(new int[] {-1,-10,2})));

印刷品

[-100, 425, 84, 8, 5, 6, 2, 1, -1]
[1, 3, 2]
[1, 2, 3]
[-10, 2, -1]

• 从找到最小值开始并保存它的位置
• 旋转到该位置。

public static int[] rotateToMin(int[] arr) {
     int pos = 0;
     int min = arr[0];
     for (int i = 1; i < arr.length; i++) {
         if (arr[i] < min) {
             min = arr[i];
             pos = i;
         }
     }
     if (pos > arr.length / 2) {
           rotateRight(arr, arr.length-pos);
     } else {
           rotateLeft(arr, pos);
     }
     return arr;
}

左右旋转方法。可能有更好的方法来做到这一点，但提供两种不同的方法是最直接的。

private static void rotateLeft(int[] arr, int count) {
    for (int k = 0; k < count; k++) {
            int save = arr[0];
            for (int i = 0; i < arr.length - 1; i++) {
                arr[i] = arr[i + 1];
            }
            arr[arr.length - 1] = save;
        }
    }

按计数单元向右旋转

private static void rotateRight(int[] arr, int count) {
    for (int k = 0; k < count; k++) { 
    int save = arr[arr.length-1];
          for (int i = arr.length - 1; i > 0; i--) {
                arr[i] = arr[i-1];
          }
          arr[0] = save;
    }
}

注意：因为你正在修改一个传递的数组，所以不需要返回它。我只是为了演示方便。

第一步：找出最小的元素，得到索引

static int findTheSmallestElementIndex(int ar[]) {

    int index = 0;
    int min = ar[0];

    for(int i=1; i<ar.length; i++) {

        if(min > ar[i]) {
            min = ar[i];
            index = i;
        }
    }

    return index;
}

第二步：使用该索引计算所需的旋转次数。

int numberOfRotations = ar.length - findTheSmallestElementIndex(ar);

步骤3：如果最小的元素已经在第一个索引处，则numberOfRotations将是0，因此不需要做任何事情，只需返回数组。
第四步：数组向右旋转一次说明

1.备份数组中最右边的元素，即最后一个元素（int temp = ar[ar.length-1];）。如果向左旋转，则选择最左侧的元素，即第一个元素。
1.从数组的最后一个索引开始for循环，并在第一个索引之前停止。（for(int i=ar.length-1; i>0; i--)）
1.将当前索引中的元素替换为其后面的元素。（ar[i] = ar[i-1];）。所以你的数组[8, 5, 6, 2, 1, -1, -100, 425, 84]在循环后将像这样转换[8, 8, 5, 6, 2, 1, -1, -100, 425]
1.用备份（ar[0] = temp;）替换第一个元素，得到旋转后的数组[84, 8, 5, 6, 2, 1, -1, -100, 425]

第五步：继续执行，直到numberOfRotations变为0。
操作完成

public static void main(String[] args) {

    int[] ar = {8, 5, 6, 2, 1, -1, -100, 425, 84};

    System.out.println(Arrays.toString(ar));
    
    System.out.println(Arrays.toString(rotateToTheRight(ar)));
}

static int findTheSmallestElementIndex(int ar[]) {

    int index = 0;
    int min = ar[0];

    for(int i=1; i<ar.length; i++) {

        if(min > ar[i]) {
            min = ar[i];
            index = i;
        }
    }

    return index;
}

static int[] rotateToTheRight(int ar[]) {

    int numberOfRotations = ar.length - findTheSmallestElementIndex(ar);
    
    if(numberOfRotations == 0)
        return ar;
    
    while(numberOfRotations-- > 0) {
        
        int temp = ar[ar.length-1];
        
        for(int i=ar.length-1; i>0; i--) {
            
            ar[i] = ar[i-1];
        }
        
        ar[0] = temp;
    }
    
    return ar;
}

用于旋转数组的代码不起作用。此代码遵循以下规则：* 不能创建和使用任何新表，也不能使用任何额外的Java类 *（除了用于打印的System和Arrays）。查看代码注解。

public class Main
{
    public static void rotateLeft(int [] array, int amount)
    {
        // Rotate the array by 1, n times
        for (int i = 0; i < amount; i++) {
            // Save the first val
            int first = array[0];
            // Shift the array left 1
            // Ex: [1,2,3,4] -> [2,3,4,4]
            for (int j = 0; j < array.length - 1; j++) {
                array[j] = array[j + 1];
            }
            // Put the value that was at index 0 in the last index
            // Ex: first = 1, [2,3,4,4] -> [2,3,4,1]
            array[array.length - 1] = first;
        }
    }
    
    // Different code when using a 2nd array
    public static int[] rotateLeft2(int [] array, int amount)
    {
        int [] newArray = new int[array.length];
        // Copy starting from the index of smallest value
        int j = 0;
        for (int i = amount; i < array.length; i++) {
            newArray[j++] = array[i];
        }
        // Copy from begining up to index of smallest
        for (int i = 0; i < amount; i++) {
            newArray[j++] = array[i];
        }
        return newArray;
    }

    // Find the index of the minimum value in the array
    public static int arrayMinIndex(int [] array)
    {
        int min = array[0];
        int minIndex = 0;
        for (int i = 1; i < array.length; i++) {
            if (array[i] < min) {
                min = array[i];
                minIndex = i;
            }
        }
        return minIndex;
    }

    public static void main(String[] args) {
        int [] array = {8,5,6,2,1,-1,-100,425,84};
        System.out.println(Arrays.toString(array));
        //rotateLeft(array, arrayMinIndex(array));
        //System.out.println(Arrays.toString(array));
        int [] b = rotateLeft2(a, arrayMinIndex(a));
        System.out.println(Arrays.toString(b));
    }
}

输出：

[8, 5, 6, 2, 1, -1, -100, 425, 84]
[-100, 425, 84, 8, 5, 6, 2, 1, -1]