Java, changement d'éléments dans un tableau
J'ai un tableau d'objets en Java et j'essaie de tirer un élément vers le haut et de déplacer le reste d'un élément vers le bas.
Supposons que j'ai un tableau de taille 10 et que j'essaie de tirer le cinquième élément. Le cinquième élément passe à la position 0 et tous les éléments de 0 à 5 seront décalés d’un unité vers le bas.
Cet algorithme ne décale pas correctement les éléments:
Object temp = pool[position];
for (int i = 0; i < position; i++) {
array[i+1] = array[i];
}
array[0] = temp;
Comment est-ce que je le fais correctement?
En supposant que votre tableau est {10,20,30,40,50,60,70,80,90,100}
Qu'est-ce que votre boucle fait est:
Itération 1: tableau [1] = tableau [0]; {10,10,30,40,50,60,70,80,90,100}
Itération 2: tableau [2] = tableau [1]; {10,10,10,40,50,60,70,80,90,100}
Ce que vous devriez faire est
Object temp = pool[position];
for (int i = (position - 1); i >= 0; i--) {
array[i+1] = array[i];
}
array[0] = temp;
Logiquement, cela ne fonctionne pas et vous devriez inverser votre boucle:
for (int i = position-1; i >= 0; i--) {
array[i+1] = array[i];
}
Sinon, vous pouvez utiliser
System.arraycopy(array, 0, array, 1, position);
Vous pouvez simplement utiliser Collections.rotate(List<?> list, int distance)
Utilisez Arrays.asList(array) pour convertir en List
plus d'infos sur: https://docs.Oracle.com/javase/7/docs/api/Java/util/Collections.html#rotate(Java.util.List,%20int)
Manipuler des tableaux de cette manière est sujet aux erreurs, comme vous l'avez découvert. Une meilleure option peut être d'utiliser LinkedList dans votre situation. Avec une liste chaînée et toutes les collections Java, la gestion des tableaux est gérée en interne, vous n'avez donc pas à vous soucier de déplacer des éléments. Avec une LinkedList, vous appelez simplement remove puis addLast et vous avez terminé.
Juste pour être complet: Solution de flux depuis Java 8.
final String[] shiftedArray = Arrays.stream(array)
.skip(1)
.toArray(String[]::new);
Je pense que je suis resté avec le System.arraycopy() dans votre situtation. Mais la meilleure solution à long terme pourrait être de tout convertir en collections immuables ( Guava , Vavr ), tant que ces collections sont de courte durée.
Essaye ça:
Object temp = pool[position];
for (int i = position-1; i >= 0; i--) {
array[i+1] = array[i];
}
array[0] = temp;
Regardez ici pour le voir fonctionner: http://www.ideone.com/5JfAg
Une opération de rotation à gauche sur un tableau de taille n décale chaque unité d'éléments du tableau vers la gauche, regardez ceci !!!
public class Solution {
private static final Scanner scanner = new Scanner(System.in);
public static void main(String[] args) {
String[] nd = scanner.nextLine().split(" ");
int n = Integer.parseInt(nd[0]); //no. of elements in the array
int d = Integer.parseInt(nd[1]); //number of left rotations
int[] a = new int[n];
for(int i=0;i<n;i++){
a[i]=scanner.nextInt();
}
Solution s= new Solution();
//number of left rotations
for(int j=0;j<d;j++){
s.rotate(a,n);
}
//print the shifted array
for(int i:a){System.out.print(i+" ");}
}
//shift each elements to the left by one
public static void rotate(int a[],int n){
int temp=a[0];
for(int i=0;i<n;i++){
if(i<n-1){a[i]=a[i+1];}
else{a[i]=temp;}
}}
}
public class Test1 {
public static void main(String[] args) {
int[] x = { 1, 2, 3, 4, 5, 6 };
Test1 test = new Test1();
x = test.shiftArray(x, 2);
for (int i = 0; i < x.length; i++) {
System.out.print(x[i] + " ");
}
}
public int[] pushFirstElementToLast(int[] x, int position) {
int temp = x[0];
for (int i = 0; i < x.length - 1; i++) {
x[i] = x[i + 1];
}
x[x.length - 1] = temp;
return x;
}
public int[] shiftArray(int[] x, int position) {
for (int i = position - 1; i >= 0; i--) {
x = pushFirstElementToLast(x, position);
}
return x;
}
}
Une autre variante si vous avez les données du tableau sous forme de liste Java
listOfStuff.add(
0,
listOfStuff.remove(listOfStuff.size() - 1) );
Juste en partageant une autre option, je me suis heurté à cela, mais je pense que la réponse de @Murat Mustafin est la solution idéale avec une liste
Au lieu de décaler d'une position, vous pouvez rendre cette fonction plus générale en utilisant un module comme celui-ci.
int[] original = { 1, 2, 3, 4, 5, 6 };
int[] reordered = new int[original.length];
int shift = 1;
for(int i=0; i<original.length;i++)
reordered[i] = original[(shift+i)%original.length];
static void pushZerosToEnd(int arr[])
{ int n = arr.length;
int count = 0; // Count of non-zero elements
// Traverse the array. If element encountered is non-zero, then
// replace the element at index 'count' with this element
for (int i = 0; i < n; i++){
if (arr[i] != 0)`enter code here`
// arr[count++] = arr[i]; // here count is incremented
swapNumbers(arr,count++,i);
}
for (int j = 0; j < n; j++){
System.out.print(arr[j]+",");
}
}
public static void swapNumbers(int [] arr, int pos1, int pos2){
int temp = arr[pos2];
arr[pos2] = arr[pos1];
arr[pos1] = temp;
}
Lors de la première itération de votre boucle, vous écrasez la valeur dans array[1]. Vous devriez parcourir les indications dans l'ordre inverse.
Vous pouvez utiliser les codes ci-dessous pour changer de vitesse:
int []arr = {1,2,3,4,5,6,7,8,9,10,11,12};
int n = arr.length;
int d = 3;
Programme pour déplacer un tableau de taille n de d éléments vers la gauche:
Input : {1,2,3,4,5,6,7,8,9,10,11,12}
Output: {4,5,6,7,8,9,10,11,12,10,11,12}
public void shiftLeft(int []arr,int d,int n) {
for(int i=0;i<n-d;i++) {
arr[i] = arr[i+d];
}
}
Programme pour déplacer un tableau de taille n de d éléments vers la droite:
Input : {1,2,3,4,5,6,7,8,9,10,11,12}
Output: {1,2,3,1,2,3,4,5,6,7,8,9}
public void shiftRight(int []arr,int d,int n) {
for(int i=n-1;i>=d;i--) {
arr[i] = arr[i-d];
}
}