Как мы можем вращать массив влево?

Question

EX: У меня есть массив {1, 2, 3, 4, 5} и целое число 7 будет повернуто 7 пространства справа, как: {4, 5, 1, 2, 3}

У меня также есть этот массив {1, 2, 3, 4, 5} и целое число -7 Он будет вращаться 7 пространства слева как: {3, 4, 5, 1, 2}

Я вращал массив вправо с помощью:

for(int i = 0; i < data.length; i++){ 
       result[(i+n) % data.length ] = data[i]; 
      } 

Но как мы можем вращать массив влево?

Answer 1

Вращение влево на n такое же, как вращение вправо по длине-n.

Поворот вправо (для положительного п):

for(int i = 0; i < data.length; i++){ 
    result[(i+n) % data.length ] = data[i]; 
} 

Поворот влево (для положительного п):

for(int i = 0; i < data.length; i++){ 
    result[(i+(data.length-n)) % data.length ] = data[i]; 
} 

Таким образом, вы можете избежать по модулю отрицательного числа.

Если вы хотите ввести целое число п, которое вращается вправо, если п положительно и слева, если п является отрицательным, вы можете сделать это следующим образом:

int[] rotateArray(int n, int[] data) 
{ 
     if(n < 0) // rotating left? 
     { 
      n = -n % data.length; // convert to +ve number specifying how 
           // many positions left to rotate & mod 
      n = data.length - n; // rotate left by n = rotate right by length - n 
     } 
     int[] result = new int[data.length]; 
     for(int i = 0; i < data.length; i++){ 
      result[(i+n) % data.length ] = data[i]; 
     } 
     return result; 
} 

Answer 2

В случае повернуть налево, вы можете использовать это, чтобы избежать по модулю отрицательного числа:

int[] data = {1, 2, 3, 4, 5}; 
int[] result = new int[data.length]; 
for (int i = 0; i < data.length; i++) { 
    result[(i + (data.length - 2)) % data.length] = data[i]; 
} 

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

Answer 3

Вы также можете использовать связанный список, чтобы достичь того же.

Integer[] arr = {1,2,3,4,5}; 

     LinkedList<Integer> ns = new LinkedList<Integer>(Arrays.asList(arr)); 
     int rotate=3; 
     if(rotate<0) 
      rotate += arr.length; 

     List<Integer> leftlist = ns.subList(0, rotate); 
     List<Integer> rightlist = ns.subList(rotate, arr.length); 

     LinkedList<Integer> result = new LinkedList<Integer>(); 
     result.addAll(rightlist); 
     result.addAll(leftlist); 

     System.out.println(result); 

Answer 4

Вот полная java-программа для n левых поворотов массива.

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); 

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

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

    public static void solution(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 display(int[] a){ 
     for(int i=0;i<a.length;i++) 
      System.out.print(a[i]+" "); 
    } 
} 

Answer 5

public static int[] arrayLeftRotation(int[] array, int elements, int rotations) { 


    // i = checks number of rotations 
    for (int i = 0; i < rotations; i++) { 

     int first = array[0]; 
     int last = array[elements - 1]; 

     // j = rotates each element 
     for (int j = 0; j < elements; j++) { 

      // check if at first index 
      if (j == 0) { 
       array[elements - 1] = first; 
      } 

      // check if at last index 
      if (j == (elements - 1)) { 

       // if at last index: make element in index before last = to last element 
       array[elements - 2] = last; 
      } else { 
       array[j] = array[j + 1]; 
      } 

     } 


    } 

    return array; 

}