Programa Java para permutar cíclicamente los elementos de una array

Dada una array de enteros, allí permutamos cíclicamente sus elementos, es decir, desplazamos cada elemento de la array un índice a la izquierda. El primer valor irá en el último índice.

Ejemplo:

Input:    [1,2,3,4,5]
Output: [2,3,4,5,1]

Input:     [2,3,1,5,6]
Output:    [3,1,5,6,2]

Enfoque #1

1. En la función CyclicShift(), el ciclo for(i=0; i<arr.length; i++) atraviesa la array y desplaza cada elemento una posición antes.
2. El primer valor de la array se almacena en la variable x antes del bucle.
3. Finalmente, el último elemento de la array se establece en x.

// Java Program to Cyclically Permute 
// the Elements of an Array
import java.util.*;
import java.io.*;
// function to print the array
class cycle {
    public int[] cycleShift(int[] arr)
    {
        int x = arr[0]; // store a[0]
        int i;
        for (i = 0; i < arr.length - 1; i++) {
            
            // for other element shift left
            arr[i] = arr[i + 1];
        }
        // for the last element in the modified array
        // it will be starting element
        arr[i] = x;
        return arr;
    }
}
public class GFG {
  
    public static void main(String[] args)
    {
        int[] arr = { 1, 2, 3, 4, 5 };
        cycle c = new cycle();
        int[] newArray = c.cycleShift(arr);
        for (int i = 0; i < newArray.length; i++) {
            System.out.print(newArray[i] + " ");
        }
    }
}

2 3 4 5 1 

• Complejidad temporal: O(n), donde n es el número de elementos de la array.
• Complejidad espacial: O(1)

Enfoque n.º 2: uso del intercambio

En la función CyclicSwap(arr) el ciclo for(int i = 0; i < arr.length; i++) el intercambio del primer elemento al siguiente elemento en la array

1. En la primera iteración, después del intercambio, será la array original [1, 2, 3, 4, 5] -> [2, 1, 3, 4, 5];
2. En la segunda iteración nuevamente después de intercambiar [2, 1, 3, 4, 5] -> [2, 3, 1, 4, 5];
3. Y esta iteración continúa hasta el final del ciclo. El resultado final sería así [2, 3, 4, 5, 1]

A continuación se muestra la implementación del enfoque anterior.

// Java Program to Cyclically Permute
// the Elements of an Array
import java.io.*;
import java.util.*;
class GFG {
    public static void main(String[] args)
    {
        int[] arr = { 1, 2, 3, 4, 5 };
        int first = arr[0];
        int start = 0;
        
        // swaping each element with the first
        // element
        for (int i = 1; i < arr.length; i++) {
            arr[start++] = arr[i];
            arr[i] = first;
        }
        // Printing the element in the
        // array.......
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

2 3 4 5 1 

• Complejidad de tiempo: O(n)
• Complejidad espacial: O(1)

Enfoque n. ° 3: usar la cola para hacer la permutación cíclica en la array

Primero, inserte todos los elementos en la cola desde el índice 1 hasta arr.length;

elimine la cola y almacene nuevamente en la array y, por último, coloque el primer elemento en el último índice de la array

// Java Program to Cyclically Permute
// the Elements of an Array
import java.io.*;
import java.util.*;
class GFG {
    public static void main(String[] args)
    {
        // use of the queue to do 
        // cyclic shift in the array
        int[] arr = { 1, 2, 3, 4, 5 };
        Queue<Integer> q = new LinkedList<>();
        int first = arr[0];
        int strt = 0;
        
        // adding each element into the queue
        for (int i = 1; i < arr.length; i++) {
            q.add(arr[i]);
        }
  
        while (!q.isEmpty()) {
            arr[strt++] = q.poll();
        }
        
        // Polling out the element from the 
        // Queue and inserting into the queue
        arr[arr.length - 1] = first;
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

2 3 4 5 1 

• Complejidad de tiempo: O(n)
• Complejidad espacial: O(n)