Как вращать массив?

Question

У меня есть следующая проблема для тестирования:

Поверните массив из n элементов вправо на k шагов.

Например, при n = 7 и k = 3 массив [1,2,3,4,5,6,7] поворачивается к [5,6,7,1,2,3,4]. Сколько разных способов вы знаете, чтобы решить эту проблему?

Мое решение в промежуточном массиве:

С Космосом O(n) и время O(n)Я могу создать новый массив, а затем скопировать элементы в новый массив. Затем измените исходный массив с помощью System.arraycopy(),

public void rotate(int[] nums, int k) {
    if(k > nums.length) 
        k=k%nums.length;

    int[] result = new int[nums.length];

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

    int j=0;
    for(int i=k; i<nums.length; i++){
        result[i] = nums[j];
        j++;
    }

    System.arraycopy( result, 0, nums, 0, nums.length );
}

Но есть ли лучший способ, которым мы можем сделать это с вращением пузыря (как сортировка пузырей) в O(1) пространство?

Answer 1

Метод 1 - Алгоритм обращения(хороший):

Алгоритм:

повернуть (обр [], д, н)

обратный (обр. [], l, n);

обратный (обр. [], 1-й);

обратный (arr[], n - d + 1, n);

Пусть AB - две части входного массива, где A = arr[0..nd-1] и B = arr[nd..n-1]. Идея алгоритма заключается в следующем:

Все наоборот, чтобы получить (AB) r = BrAr.

Обратный, чтобы получить BrA. /* Ar противоположна A */

Обратный B, чтобы получить BA. /* Br противоположен B */

Для arr[] = [1, 2, 3, 4, 5, 6, 7], d =2 и n = 7

A = [1, 2, 3, 4, 5] и B = [ 6, 7]

Обратно все, получаем BrAr = [7, 6, 5, 4, 3, 2, 1]

Реверс A, получаем ArB = [7, 6, 1, 2, 3, 4, 5] Реверс B, получаем ArBr = [6, 7, 5, 4, 3, 1, 2]

Вот фрагмент кода:

void righttRotate(int arr[], int d, int n)
{
  reverseArray(arr, 0, n-1);
  reverseArray(arr, 0, n-d-1);
  reverseArray(arr, n-d, n-1);
}

void reverseArray(int arr[], int start, int end)
{
  int i;
  int temp;
  while(start < end)
  {
    temp = arr[start];
    arr[start] = arr[end];
    arr[end] = temp;
    start++;
    end--;
   }
}

Метод 2 - Алгоритм жонглирования

Разделите массив на различные наборы, где количество наборов равно GCD для n и d, и переместите элементы в наборах.

Если GCD равен 1, то элементы будут перемещаться только в пределах одного набора, мы просто начинаем с temp = arr[0] и продолжаем перемещать arr[I+d] в arr[I] и, наконец, сохраняем temp в нужном месте.

Вот пример для n = 12 и d = 3. GCD равен 3 и

Пусть arr [] будет {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}

1. Элементы сначала перемещаются в первый набор arr [] после этого шага -> {4 2 3 7 5 6 10 8 9 1 11 12}

2. Затем во втором сете. arr[] после этого шага -> {4 5 3 7 8 6 10 11 9 1 2 12}

3. Наконец в третьем сете. arr[] после этого шага -> {4 5 6 7 8 9 10 11 12 1 2 3}

Вот код:

void leftRotate(int arr[], int d, int n)
{
  int i, j, k, temp;
  int gcd = gcd(d, n);
  for (i = 0; i < gcd; i++)
  {
    /* move i-th values of blocks */
    temp = arr[i];
    j = i;
    while(1)
    {
      k = j + d;
      if (k >= n)
        k = k - n;
      if (k == i)
        break;
      arr[j] = arr[k];
      j = k;
    }
    arr[j] = temp;
  }
}

int gcd(int a,int b)
{
   if(b==0)
     return a;
   else
     return gcd(b, a%b);
}

Временная сложность: O(n)

Вспомогательное пространство: O(1)

Метод 3 - Поворот по одному:

righttRotate (arr [], d, n)

Начните

Для i = 0 до i

Поверните вправо все элементы arr [] на один

конец

Чтобы повернуть на единицу, сохраните arr [n-1] во временной переменной temp, переместите arr [1] в arr [2], arr [2] в arr[3] … и, наконец, в temp arr [0]

Давайте возьмем тот же пример arr[] = [1, 2, 3, 4, 5, 6, 7], d = 2, поверните arr [] по одному 2 раза. Мы получаем [7, 1, 2, 3, 4, 5, 6] после первого вращения и [ 6, 7, 1, 2, 3, 4, 5] после второго вращения.

Ее кодовый фрагмент:

void leftRotate(int arr[], int d, int n)
{
  int i;
  for (i = 0; i < d; i++)
    leftRotatebyOne(arr, n);
}

void leftRotatebyOne(int arr[], int n)
{
  int i, temp;
  temp = arr[n-n];
  for (i = 0; i < n-1; i++)
     arr[i] = arr[i+1];
  arr[n - 1] = temp;
}

Временная сложность: O(n*d)

Вспомогательное пространство: O(1)

Answer 2

Вам не нужно forпетли.

public int[] rotate(int[] nums, int k) {
     if(k > nums.length) 
          k=k%nums.length;

     int[] result = new int[nums.length];
     System.arraycopy( nums, k+1, result, 0, k );
     System.arraycopy( nums, 0, result, k+1, nums.length-1 );

     //Case 1: The rotated array will be assigned to the given array "nums"
     nums = result;

     return result; //Case 2: method returns the rotated array
}

Спецификацию arraycopy можно найти здесь http://docs.oracle.com/javase/7/docs/api/java/lang/System.html

Не тестет. Общая сложность метода поворота O(1).

Если ваш вопрос был обо всех возможных перестановках, посмотрите здесь Java Code для перестановок списка чисел.

Другой совет - проверить API Java Collection, который предоставляет множество сложных структур данных и общих алгоритмов сортировки, которые реализованы очень эффективным способом.

РЕДАКТИРОВАТЬ из-за комментария.

Метод возвращает повернутый массив. Вы можете использовать метод внутри внешнего метода, например так: (просто псевдокод)

void rotator(int[] nums) {        
       int rotated[] = nums;
       //Can be invoked iteraritve or within a loop like this
       rotated = rotate(rotated, 3);          
}

Answer 3

Следующий код сделает вашу работу. Это для правого поворота.

public void rightrotate(int[] nums, int k) {
    k %= nums.length;
    reverse(nums, 0, nums.length - 1);
    reverse(nums, 0, k - 1);
    reverse(nums, k, nums.length - 1);
}

public void reverse(int[] nums, int start, int end) {
    while (start < end) {
        int temp = nums[start];
        nums[start] = nums[end];
        nums[end] = temp;
        start++;
        end--;
    }
}

Если вы хотите сделать левый поворот, просто используйте следующее

 public void leftrotate(int[] nums, int k) {
    k %= nums.length;
    reverse(nums, 0, k - 1);
    reverse(nums, k, nums.length - 1);
    reverse(nums, 0, nums.length - 1);
}

Answer 4

Пространство - это O(1), а время - это O(n)

static void rotate(int[] array, int k) {
    int size = array.length;
    if (size <= 1) return;
    k = k % size;
    if (k == 0) return;
    for (int i = 0, start = 0, from = 0, to = -1, move = array[0]; i < size; ++i, from = to) {
        to = (from + k) % size;
        int temp = array[to];
        array[to] = move;
        move = to == start ? array[to = ++start] : temp;
    }
}

Answer 5

Класс ArrayUtil используется для предоставления следующих утилит в примитивном массиве

1. элементы массива подкачки
2. обратный массив между startIndex и endIndex
3. массив leftRotate по сдвигу

---

Алгоритм вращения массива сдвигом

1. Если нам нужно повернуть массив по значению смещения, тогда возьмите mod (%) с длиной массива, чтобы смещение стало меньше длины массива.
2. Обратный массив между индексом 0 и shift-1
3. Обратный массив между смещением индекса и длиной -1.
4. Обратный полный массив между индексом 0 и длиной-1.

Сложность пространства: алгоритм на месте, дополнительное пространство не требуется, поэтому O (1).

Сложность времени: Обращение массива размера k принимает O(k/2), т. Е. Обменивается k / 2 парами элементов.

Время обращения массива - O(k) для массива размера k.

Общее время в Rotation-

• O (1).......... для шага 1
• O (смещение)...... для шага 2
• O (n - shift)... для шага 3
• O (n)........... для шага 4

Общее время вращения массива: O(1) + O(сдвиг) + O(n-сдвиг) + O(n) = O(n)

public class Solution {

    public static void main(String[] args) {
        int k = 3;
        int a[] = {1,2,3,4,5,6,7};

        ArrayUtil.leftRotate(a, k);

        for (int i : a)
            System.out.println(i);
    }
}

class ArrayUtil {

    public static final boolean checkIndexOutOfRange(int[] array, int index) {
        if (index < 0 || index > array.length)
            return true;
        return false;
    }

    public static final void swap(int[] array, int i, int j) {
        if (checkIndexOutOfRange(array, i) || checkIndexOutOfRange(array, j))
            return;
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }

    public static final void reverse(int[] array, int startIndex, int endIndex) {
        if (checkIndexOutOfRange(array, startIndex) || checkIndexOutOfRange(array, endIndex))
            return;
        while (startIndex < endIndex) {
            swap(array, startIndex, endIndex);
            startIndex++;
            endIndex--;
        }
    }

    public static final void reverse(int[] array) {
        reverse(array, 0, array.length - 1);
    }

    public static final void leftRotate(int[] array, int shift) {
        int arrayLength = array.length;
        if (shift >= arrayLength)
            shift %= arrayLength;
        reverse(array, 0, shift - 1);
        reverse(array, shift, arrayLength - 1);
        reverse(array);
    }
}

Answer 6

В Ruby это очень просто, пожалуйста, посмотрите, это одна строка.

def array_rotate(arr)
    i, j = arr.length - 1, 0
    arr[j],arr[i], i, j = arr[i], arr[j], i - 1, j + 1 while(j<arr.length/2)
    puts "#{arr}"
end

Вход: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

Выход: [20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

Answer 7

Код Python:

def reverse(arr,start , end):   
    while(start <= end):
        arr[start] , arr[end] = arr[end] , arr[start]
        start = start+1
        end = end-1

arr = [1,2,3,4,5,6,7]
n = 7
k = 2
reverse(arr,0,n-1)
# [7,6,5,4,3,2,1]
reverse(arr,0,n-1-k)
# [3,4,5,6,7,2,1]
reverse(arr,n-k,n-1)
# [3,4,5,6,7,1,2]

print arr
# [3, 4, 5, 6, 7, 8, 9, 1, 2]

Answer 8

Частичный код для ОДНОГО поворота массива времени

       last=number_holder[n-1];
       first=number_holder[0];
        //rotation 

        number_holder[0]=last;

        for(i=1;i<n;i++)
        {
            last=number_holder[i];
            number_holder[i]=first;
            first=last;
        }

Показать массив

        for(i=1;i<n;i++)
        {
          System.out.println(number_holder[i]);
        }

Answer 9

AFAIK, есть три способа повернуть массив с O(1) дополнительным пространством, или, другими словами, поменять местами два смежных подмассива.

• обратный подход. поменять обе части, потом поменять все. проще всего кодировать.
• последовательно меняйте местами два смежных блока, пока все элементы не будут на месте.
• жонглирование вращаться, оболочки вроде как. - хуже производительность кеша.

C++ имеет встроенную функцию std::rotate(), который занимает три итератора first, middle, last, и вернуться new_middle, где старый первый элемент лежит в повернутой последовательности.

Я проверил реализацию на моем компьютере, которая использует второй подход, который я перечислил выше. (строка 1246 в /usr/lib/gcc/i686-pc-cygwin/5.4.0/include/c++/bits/stl_algo.h).

Ниже моя реализация rotate с тестовой программой.

#include <iostream>
#include <vector>

// same logic with STL implementation, but simpler, since no return value needed.
template <typename Iterator>
void rotate_by_gcd_like_swap(Iterator first, Iterator mid, Iterator last) {
    if (first == mid) return;
    Iterator old = mid;
    for (; mid != last;) {
        std::iter_swap(first, mid);
        ++first, ++mid;
        if (first == old) old = mid; // left half exhausted
        else if (mid == last) mid = old;
    }
}

// same logic with STL implementation
template <typename Iterator>
Iterator rotate_by_gcd_like_swap_then_return_new_mid(Iterator first, Iterator mid, Iterator last) {
    if (first == mid) return last;
    if (mid == last) return first;
    Iterator old = mid;
    for(;;) {
        std::iter_swap(first, mid);
        ++first, ++mid;
        if (first == old) old = mid;
        if (mid == last) break;
    }
    Iterator result = first; // when first time `mid == last`, the position of `first` is the new `mid`.
    for (mid = old; mid != last;) {
        std::iter_swap(first, mid);
        ++first, ++mid;
        if (first == old) old = mid;
        else if (mid == last) mid = old;
    }
    return result;
}

int main() {
    using std::cout;
    std::vector<int> v {0,1,2,3,4,5,6,7,8,9};
    cout << "before rotate: ";
    for (auto x: v) cout << x << ' '; cout << '\n';
    int k = 7;
    rotate_by_gcd_like_swap(v.begin(), v.begin() + k, v.end());
    cout << " after rotate: ";
    for (auto x: v) cout << x << ' '; cout << '\n';
    cout << "sz = " << v.size() << ", k = " << k << '\n';
}

Answer 10

1. использование временного массива и O(n) времени

public static void rotateAnArrayUsingTemp(int arr[], int d, int n) {
    int temp[] = new int[d];
    int tempIndex = 0;
    for (int i = 0; i < d; i++) {
        temp[i] = arr[i];
    }
    for (int i = 0; i < arr.length - d; i++) {
        arr[i] = arr[i + d];
    }
    for (int i = arr.length - d; i < arr.length; i++) {
        arr[i] = temp[tempIndex++];
    }
}

Answer 11

Приведенные выше решения говорят о смещении элементов массива путем их обращения или любой другой альтернативы.

У меня есть уникальное решение. Как насчет определения начальной позиции элемента после n поворотов. Как только мы это узнаем, просто вставьте элементы из этого индекса и увеличьте счетчик, используя операцию модуля. Используя этот метод, мы можем избежать использования дополнительных операций с массивами и так далее.

Вот мой код:

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

void rotateLeft(int n,int r) {
    vector<long int> vec(n);
    int j = n;
    // get the position of starting index after r left rotations.
    while(r!=0) {
        --j;
        if(j==0)
            j = n;
        --r;
    }
    for(long int i=0;i<n;++i) {
        // simply read the input from there and increment j using modulus operator.
        cin>>vec[j];
        j = (j+1)%n;
    }
    // print the array
    for(long int i=0;i<n;++i) 
        cout<<vec[i]<<" ";
}
int rotateRight (int n,int r) {
    // get the position of starting index after r left rotations.
    int j = r % n;

    vector<long int> vec(n);
    for(int i=0;i<n;i++) {
        cin>>vec[j];
        j=(j+1)%n;
    }
    for(int i=0;i<n;i++)
        cout<<vec[i]<<" ";

}
int main() {

    long int n,r;   // n stands from number of elements in array and r stands for rotations.
    cin>>n>>r;
    // Time Complexity: O(n+r) Space Complexity: O(1)
    rotateLeft(n,r);
    // Time Complexity: O(n) Space Complexity: O(1)
    rotateRight(n,r);
    return 0;

}

Answer 12

Это вращает массив вправо на k шагов, где k неотрицательно

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

   }
  return nums;

Answer 13

    if (k > arr.length) {
        k = k % arr.length;
    }
    int n = arr.length - k;
    int count = 0;
  outer:
    for (int i = arr.length - 1; i >= n; i--) {
         int temp = arr[i];
       inner:
         for (int j = i - 1; j >= 0; j--) {
             arr[j + 1] = arr[j];
             if (j == 0) {
                 int temp2 = arr[j];
                 arr[j] = temp;
                 i = arr.length;
                 count++;
                 if (count == k) {
                     break outer;
                 }
             }
         }
     }
    

Answer 14

Это решение - O(1) пространство и O(N) время. Он находится в C#, принимает параметр массива и вращает его на месте. Алгоритм проходит через первые элементы s (сдвиг), начиная с первого элемента, перемещает его в позицию s_th, затем перемещает элемент s_th в позицию 2s_th и т. Д. Если каждый из первых элементов s поворачивается обратно к самому себе, тогда будет (arrayLength / s) * s = arrayLength зацикливается, и в конце массив будет повернут на s. Если первые элементы s не вращаются назад сами по себе, то все равно будут циклы, скажем, если s = 4, может быть один цикл, который является 1-3-1, а второй 2-4-2, строка - если (ind == indAtBeg), проверяет цикл и завершает цикл while. Переменная loopCount увеличивается, когда вращение начинается с любого из первых s элементов.

    public static void rotateArrayByS(int[] ar, int s)
    {
        int len = ar.Length, ind = 0, temp1 = ar[0], 
            temp2 /*temp1 and temp2 for switching elements*/, 
            loopCount /*rotations starting at the first s elemtns of ar*/ = 0;

        s %= len;

        while (loopCount < s)
        {
            int indAtBeg = ind;
            temp1 = ar[ind];

            bool done = false;
            while (!done)
            {
                if (ind < s)
                    loopCount++;

                ind = (ind + s) % len;

                //cycle detected
                if (ind == indAtBeg)
                    done = true;

                //switch the elements
                temp2 = ar[ind];
                ar[ind] = temp1;
                temp1 = temp2;
            }

            ++ind;
        }
    }

Answer 15

Здесь я решил ту же проблему на ходу. Попробуй побегать на детской площадке ...

образец кода.

      func rotate(a []int, k int)  {
    for j := 0; j < k ; j++ {
        temp := a[len(a)-1]
        for i := len(a) - 1; i > 0; i-- {
            a[i] = a[i-1]
        }
        a[0] = temp
    }
}

Answer 16

Если вы ищете решение проблемы Codility — Cyclic Rotation , то вот код JavaScript , который дал мне 100%.

      function solution(A, K) {
  const L =  A.length - (K % A.length);    // to get the rotation length value below array length (since rotation of product of array length gives same array)
  const A1 = A.slice(L);                   // last part of array which need to be get to front after L times rotation
  const A2 = A.slice(0, L);                // part which rotate L times to right side
  const Result = [...A1, ...A2];           // reverse and join both array by spreading
  return Result;
}

Answer 17

Мое решение... (a: массив, n: размер массива, k: количество смен):

 public static int[] arrayLeftRotation(int[] a, int n, int k) {

    if (k == 0) return a;

    for (int i = 0; i < k; i++) {
        int retenue = a[0];
        int[] copie = java.util.Arrays.copyOfRange(a, 1, n );
        for (int y = 0; y <= copie.length - 1 ; y++) {
            a[y] = copie[y];
        }
        a[n-1] = retenue;
    }
    return a;
}

Answer 18

Java-реализация для вращения вправо

            public int[] solution(int[] A, int K) {
                int len = A.length;
                //Create an empty array with same length as A
                int arr[] = new int[len];

                for (int i = 0; i < len; i++) {
                    int nextIndex = i + K;
                    if (nextIndex >= len) {
                        // wraps the nextIndex by same number of K steps
                        nextIndex = nextIndex % len;
                    }
                    arr[nextIndex] = A[i];
                }
                return arr;
            }

Answer 19

Вот полный Java-код для вращения левого и правого массива на k шагов

import java.util.*;

public class ArrayRotation {
    private static Scanner sc;

    public static void main(String[] args) {
        int n,k;
        sc = new Scanner(System.in);
        System.out.print("Enter the size of array: ");
        n = sc.nextInt();

        int[] a = new int[n];
        System.out.print("Enter the "+n+" elements in the list: ");
        for(int i=0;i<n;i++)
            a[i] = sc.nextInt();

        System.out.print("Enter the number of left shifts to array: ");
        k = sc.nextInt();

        System.out.print("Array before "+k+" shifts: ");
        display(a);

        leftRoation(a,k);
        System.out.println();

        System.out.print("Array after "+k+" left shifts: ");
        display(a);

        rightRoation(a,k);
        System.out.println();

        System.out.print("Array after "+k+" right shifts: ");
        display(a);
    }

    public static void leftRoation(int[] a, int k){
        int temp=0, j;
        for(int i=0;i<k;i++){
            temp = a[0];
//          j=0;                    // both codes work i.e. for loop and while loop as well
//          while(j<a.length-1){
//              a[j]=a[j+1];
//              j++;
//          }   
            for(j=0;j<a.length-1;j++)
                a[j]=a[j+1];
            a[j]=temp;
        }           
    }

    public static void rightRoation(int[] a, int k){
        int temp=0, j;
        for(int i=0;i<k;i++){
            temp = a[a.length-1];
            for(j=a.length-1;j>0;j--)
                a[j]=a[j-1];
            a[j]=temp;
        }           
    }

    public static void display(int[] a){
        for(int i=0;i<a.length;i++)
            System.out.print(a[i]+" ");
    }
}

/****************** Output ********************
    Enter the size of array: 5
    Enter the 5 elements in the list: 1 2 3 4 5
    Enter the number of left and right shifts to array: 2
    Array before 2 shifts: 1 2 3 4 5 
    Array after 2 left shifts: 3 4 5 1 2 
    Array after 2 right shifts: 1 2 3 4 5  // here the left shifted array is taken as input and hence after right shift it looks same as original array.
 **********************************************/

Answer 20

Повернуть массив из n элементов вправо на k шагов.

Например, при n = 7 и k = 3 массив [1,2,3,4,5,6,7] вращается до [5,6,7,1,2,3,4].

В JS решение будет состоять из 2 частей, в две строки:

      function rotateArray(array,k){
  // remove the rotation part
  const splice = [...array].splice(0,k); //... for make a clone;
  // add reversed version of the what left 
  return array.concat(splice.reverse()) from original array. 
}

Answer 21

Лучший способ повернуть массив на k шагов:

a = [1,2,3,4,5,6]
b = a[:]
k = 2
for i in range(len(a)):
    a[(i + k) % len(a)] = b[i]## (rotate right by k steps)
    #a[(i - k) % len(a)] = b[i]## (rotate left by k steps)
print(a)

о / п: [6, 5, 1, 2, 3, 4]

Answer 22

Как повернуть массив, В этой функции первый аргумент - массив, второй аргумент - это число или целое число.

def rotLeft(a, d):
    data = a
    n = d
    get = data[n:len(data)]
    remains = data[0:n]
    data.clear()
    for i in get:
        data.append(i)
    for x in remains:
        data.append(x)
    return data

Answer 23

>>> k = 3
>>> arr = [1,2,3,4,5,6,7]
>>> actual_rot = k % len(arr)
>>> left_ar = arr[:-actual_rot]
>>> right_ar = arr[-actual_rot:]
>>> result = right_ar + left_ar
>>> result
[5, 6, 7, 1, 2, 3, 4]

Answer 24

#include <stdio.h>

int
main(void)
{
    int arr[7] = {1,2,3,4,5,6,7};
    int new_arr[7] = {0};
    int k = 3;
    int len = 7;
    int i=0;

    for (i = (len-1); i>=0; i--) {
        if ((i+k) >= len) {
            new_arr[(i+k-len)] = arr[i];
        } else {
            new_arr[(i+k)] = arr[i];
        }
    }

    for (i=0;i<len;i++) {
        printf("%d ", new_arr[i]);
    }

    return 0;
}

Временная сложность O(n) Пространственная сложность O(2*n).

Благодарю.

Answer 25

Это простое решение для вращения массива.

public class ArrayRotate {
    public int[] rotateArray(int array[], int k) {

        int newArray[] = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            newArray[(i + k) % array.length] = array[i];
        }
        System.arraycopy(newArray, 0, array, 0, array.length);
        return newArray;

    }

    public static void main(String[] args) {
        int array[] = { 1, 2, 3, 4, 5, 6, 7 };
        ArrayRotate rotate = new ArrayRotate();
        rotate.display(rotate.rotateArray(array, 3));

    }

    public void display(int array[]) {
        for (int i : array) {
            System.out.print(i + ",");
        }
    }
}

Сложность во время выполнения O(n)

Есть несколько других алгоритмов для достижения того же.

• используя временный массив
• Поверните один за другим
• Алгоритм жонглирования
• метод обращения

Answer 26

Шаг 1. Поворот массива вправо на единицу.

1. Возьмите резервную копию самого правого элемента массива, последнего элемента (int temp = ar[ar.length-1];). Если вы поворачиваете влево, выберите самый левый элемент, первый элемент.
2. Запустите цикл for с последнего индекса массива и остановите его прямо перед первым индексом (for(int i=ar.length-1; i>0; i--)).
3. Замените элемент из текущего индекса на тот, который находится сразу за ним.(ar[i] = ar[i-1];). Массив[8, 5, 6, 2, 1, -1, -100, 425, 84]после того, как цикл будет[8, 8, 5, 6, 2, 1, -1, -100, 425].
4. Замените первый элемент резервным (ar[0] = temp;), давая вам повернутый массив как[84, 8, 5, 6, 2, 1, -1, -100, 425].

Теперь продолжайте этот процесс до тех пор, покаkстановится0

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

Answer 27

Кажется, Вы можете сделать это таким простым способом:

 public static void main(String[] args) {
        int arr[] = {1, 2, 3, 4, 5, 6, 7,8,9};
        System.out.println();
        System.out.println(Arrays.toString(rotateArray(arr, 5)));
    }


   static int [] rotateArray(int arr [], int k){
        int [] newArr = new int [arr.length];
        int newIndex = 0;
        for(int i  = k; i < arr.length; i ++){
            newArr[newIndex++] = arr[i];
        }
        for(int i = 0; i < k; i++ ){
            newArr[newIndex++] = arr[i];
        }
       return newArr;
    }