J'aimerais comprendre pourquoi ça ne fonctionne pas

Salut à tous,
quand je compile la classe testTri, le compilateur me dit: "illegal start of expression". Il me signale l'erreur , au niveau de:
un.tab={3,2,0,9,8,4}. Je ne comprends pas

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

class Tri{ int tailleTableau; int[] tab;   void triCroissant(){   tab= new int[tailleTableau]; int[] tmp; tmp=tab;   for(int i=0;i<tailleTableau-1;i++){ if(tab[i]>tab[i+1]){ tmp[i]=tab[i]; tab[i]=tab[i+1]; tab[i+1]=tmp[i]; System.out.println(tab[i]); } } }

---

Code:

---

1 2 3 4 5 6 7 8

class TestTri{ public static void main(String[] args){ Tri un=new Tri(); un.tab={3,2,0,9,8,4}; un.triCroissant(); } }

---

Bonjour,

C'est comme ça qu'on instancie un tableau en Java :

Code:

---

int[] tableau = new int[]{3,2,0,9,8,4};

---

Romain.

mon algorithme est faux, je viens de m'en rendre compte. Je vais le corriger. Je pense qu'il me faut deux "for"

Je ne sais pas si tu souhaites impérativement développer la fonction de tri toi même, mais il en existe déjà une en Java :

Code:

---

1 2 3

int[] tableau = new int[]{3,1,2}; Arrays.sort(tableau); // le tableau est maintenant dans l'ordre 1, 2, 3

---

Romain.

Je souhaite la développer

Salut à tous!
Je rencontre une petite difficulté.
J'ai vu qu'il y a deux boucles "for". Cependant, ma difficulté c'est de déterminer N qui porte sur j (c'est-à dire le nombre de fois qu'on pourra faire tourner la boucle for(int i=0; i<tailleTableau; i++) pour que le tableau soit complètement trié)

Code:

---

1 2 3 4 5 6 7 8 9

for(int j=0; j<N; J++) for(int i=0; i<tailleTableau-1; i++){ if(tab[i]>tab[i+1]){ tmp[i]=tab[i]; tab[i]=tab[i+1]; tab[i+1]=tmp[i]; } }

---

Tu n'as qu'à faire un dessin, avec un tableau de 3 ou 4 cases. La réponse deviendra évidente.
(Et ce serait bien de toujours le faire. L'informatique ça marche comme ça.)

Pour les plus matheux, il y a aussi la méthode consistant à énoncer l'invariant de chaque boucle. Une fois que c'est fait, on comprend tout de suite de où à où la boucle doit aller.

Bonjour,

voici un algorithme qui te permet de trier un tableau d'entier:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

int tab[]= {4,2,3,0,1,7}; int tmp =0; for(int i=0; i<tab.length; i++){ for(int j=0 ; j<tab.length; j++) if(tab[j]>tab[i]){ tmp = tab[i]; tab[i] = tab[j]; tab[j] = tmp; } }

---

Salut,

Code:

---

1 2 3 4 5 6 7 8 9

for(int j=0; j<N; J++) for(int i=0; i<M; i++){ if(tab[i]>tab[i+1]){ tmp[i]=tab[i]; tab[i]=tab[i+1]; tab[i+1]=tmp[i]; } }

---

pour répondre à JamesBond, je dirai ceci:

Si n est la taille du tableau, dans la boucle for(int i=0;i<M;i++), M correspond au nombre de fois qu'on peut inverser les couples tab[i] et tab[i+1], donc M=n-1
prenons par exemple le tableau
(7,6,5,4,3),

i=0 7>6 (6,7,5,4,3)
i=1 7>5 (6,5,7,4,3)
i=2 7>4 (6,5,4,7,3)
i=3 7>3 (6,5,4,3,7)

on voit bien que n=5 et i prend 5-1 =4 valeurs

Voyons maintenant la boucle for(int j=0; j<N; j++),
Si n est la taille du tableau, pour une valeur donnée de j, un nombre ne peut être déplacé que de n-1 cases au maximum quand on parcourt une fois la boucle(c'est-à-dire quand i prend les valeurs i=0; i=1;....i=n-2). Un exemple pour illustrer ça, considérons l'exemple ci-dessus:
Pour la valeur j=0,
on voit que 7 est parti de tab[0] et est arrivé à tab[5]. Donc 7 n'a été déplacé que de 4 (5-1) cases de tab[1] à tab[5].
on voit que 6 n'a été déplacé que d'une case.
5 n'a été déplacé que d'une case, 4 et 3 aussi.

Donc un nombre ne peut bouger au maximum que de n-1 cases ou au minimum que d'une case pour une valeur donnée de j.

Pour ce qui est de la valeur N, en fait cette valeur peut varier d'un cas à l'autre. Un exemple où les tableaux ont même dimension:

pour (2,4,3) on parcourt la boucle i une seule fois pour j=0, pour trier le tableau suivant un ordre croissant.Donc N=1.
par contre pour (4,3,0), on parcourt la boucle i deux fois pour j=0 et j=1, pour trier le tableau suivant un ordre croissant. Donc N=2.

Effectivement, il y a une difficulté pour le choix de N. Il est donc mieux de prendre la plus grande valeur que peut prendre N, même si certaines valeurs de j seront inutiles.

Pour trouver la valeur de N, nous avons vu qu'une valeur ne peut bouger au minimum que d'une case ou au maximum de n-1 cases. Plaçons nous dans le cas où à chaque boucle i, une valeur ne bouge que d'une case. Cela veut dire
quand la valeur aura fait bouger de n-1 cases, on aura fait n-1 boucles i. Donc N=n-1.
N=n-1 c'est la plus grande valeur qu'on puisse prendre.

... Ou alors on fait juste un tri par insertion ou par sélection tout simple -_-°.

Merci javamar, j'ai bien compris.
Je vais d'abord au bout de mon idée. J'essayerai aussi de faire par insertion et autre.
Mais le problème qui se pose, c'est au niveau de l'exécution. J'ai l'impression que le compilateur ne lit pas le tableau que j'ai déclaré dans main. Parceque quand j'affiche le tableau, je n'ai que des valeurs 0,0,0,0,0,0. c'est comme si il ne tient compte que de l'instruction Tri un =new Tri(); Je me demande si c'est la bonne façon d'initialiser le tableau en mettant un.tab=new int[]{3,2,0,9,8,4}

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

class Tri{ int tailleTableau; int[] tab;   void triCroissant(){ int[] tmp;   for(int j=0; j<tailleTableau-1; j++){ for(int i=0;i<tailleTableau-1;i++){ tab= new int[tailleTableau]; tmp=tab; if(tab[i]>tab[i+1]){ tmp[i]=tab[i]; tab[i]=tab[i+1]; tab[i+1]=tmp[i]; } System.out.println(tab[i]);   } } } }

---

Code:

---

1 2 3 4 5 6 7 8

class TestTri{ public static void main(String[] args){ Tri un=new Tri(); un.tab=new int[]{3,2,0,9,8,4}; un.triCroissant(); } }

---

Si je ne me trompe pas, l'insertion de données dans un tableau sous la forme int[] truc = { a , b , c }; ne peut se faire qu'à la déclaration du dit tableau. Hors, dans votre cas, il s'agit d'une variable public de votre classe Tri, qui est déjà instancié. Dans votre cas, si on ne veut pas toucher à la structure de votre méthode, je ferai ainsi :

Code:

---

1 2	in[] tableauTmp = { 3, 2 , 0 , 9 , 8 , 4 }; un.tab = tableauTmp;

---

De plus, je viens de lire attentivement votre code, euh, tel-quel il ne peut pas fonctionner. Ou du moins il ne donne rien...8O
Dans votre seconde boucle, non seulement vous réinitialisez votre tableau tab (dans ce cas, pourquoi lui donner une valeur avant d'invoquer la méthode qui commence par le vider ?), mais en plus, vous le faites à chaque boucle ?!... et pour finir, ce code ne devrait même pas être compilable puisque à aucun endroit vous ne définissez la valeur de tailleTableau ?!.... ça ne peut pas fonctionner.:?

A votre place je commencerai par créer un constructeur pour la classe Tri demandant un int[] en paramètre :

Code:

---

1 2 3 4 5 6 7 8 9 10

class Tri{ int tailleTableau; int[] tab;   public Tri(int[] tab) { this.tab = tab; tailleTableau = tab.length; } ..... ...

---

Puis, je modifierai légèrement la méthode pour qu'elle serve à quelque chose :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

void triCroissant(){ int[] tmp; for(int j=0; j<tailleTableau-1; j++){ for(int i=0;i<tailleTableau-1;i++){ tmp=tab; if(tab[i]>tab[i+1]){ tmp[i]=tab[i]; tab[i]=tab[i+1]; tab[i+1]=tmp[i]; } } } for (int o = 0 ; o < tailleTableau ; o++) System.out.println(tab[o]); } .... ...

---

Pour ce qui est de la classe de test, ça donnerai la chose suivante :

Code:

---

1 2 3 4 5 6 7

class TestTri{ public static void main(String[] args){ int[] test = { 3 , 2 , 0 , 9 , 8 , 4}; Tri un = new Tri(test); un.triCroissant(); } }

---

salut à tous!


1)
Quand tu fais tmp=tab cela veut dire que tmp [i]=tab[i] pour tout i appartenant à {0,1,…..tailleTableau} c’est-à-dire pour i=0;i=1.….i=tailleTableau-1.
Je ne comprends pas dans quel intérêt tu as fait tmp=tab. Si c’est dans le soucis de conserver le tableau d’origine, sache que tab n‘est pas conservé. Quand tu permutes tab[i] et tab[i+1], il est clair que l’objet que référencie tab est modifié, donc le tableau tmp est aussi modifié car tab et tmp référencie le même objet.
Donc ton tableau tab ne sera pas conservé.

2)
Et le fait d’écrire tmp[i]=tab[i]
Ne marche pas quand tu permutes les tab[i] et tab[i+1]. Prenons l’exemple de ton tableau {3,2,0,9,8,4}
Ton algorithme veut qu’on mette d’abord la valeur tab[0]=3 dans tmp[0], on aura ainsi tmp[0]=3.
Ensuite mettre tab[1] dans tab[0], donc on aura tab[0]=2 car tab[1]=2.Et là tmp[0] qui était égale à la valeur 3 prend la valeur 2 car tab[0]=tmp[0] (n’oublions pas que tab et top référencient le même objet).
Au final, on a pas fait une permutation du couple (3,2) car au lieu de (3,2), on se retrouve avec (2,2)

3)
Donc pour éviter le fait que tmp[i]=tab[i] pose problème, tu mets tab[i] dans une variable tmp ( tmp= tab[i] )


4)
Contrairement à ce que dit rg77140,On peut bien initialiser le tableau {3,2,0,9,8,4} comme-ceci:
int [] tab={3,2,0,9,8,4}.
Mais on utilise les accolades {…..} que si c’est une déclaration.
Donc on peut bien écrire: int[] tab={3,2,0,9,8,4}
Parce que tab est déclaré et donc on peut utiliser les accolades pour lui attribuer les valeurs. En effet quand le compilateur voit que le tableau est déclaré,et s'il rencontre les valeurs initialisation entre accolades, il invoque automatiquement l'operateur new pour créer un objet de type tableau et y met les valeurs entre accolades.

Par contre quand tu écris dans la méthode main()
un.tab={3,2,0,9,8,4}
un.tab n’est pas une déclaration, donc on ne peut pas lui attribuer les valeurs en mettant juste des accolades.
C’est pourquoi le compilateur te dit:
«*illégal start of expression*» car il ne peut pas invoquer automatiquement l'operateur new.

Dans ce cas, pour éviter ce problème, c'est à toi de mettre l'operateur new qui te permet de creer l'objet tableau:
un.tab=new int[] {3,2,0,9,8,4};
Qui veut dire que tu crées un tableau de taille 6, pour l’objet un
Et tu y mets les valeurs 3,2,0,9,8,4


Tu peux aussi utiliser tab comme paramètre de la methode triCroissant() et écrire:

triCroissant(int[] tab), dans ce cas tab ne sera plus une variable d'instance de la classe Tri et tu pourras alors initialiser ton tableau dans la methode main() comme suit:

int[] ts={3,2,0,9,8,4}



5)
Pourquoi il n’y a que des valeurs 0 qui sont affichées?

Le fait que ton algorithme affiche maintenant les valeurs 0, je suppose que tu as tenu compte de la remarque de rg77140 d’initialiser ton tableau comme suit:

un.tab=new int[]{3,2,0,9,8,4}

Dans la méthode main(), tu as donc mis :
un.tab=new int[]{3,2,0,9,8,4}
Mais dans la méthode triCroissant() tu as mis:
tab=new int[tailleTableau]
Ce qui fait que tab qui referencie l’objet {3,2,0,9,8,4} ne le referencie plus quand tu rentres dans la methode triCroissant(), il referencie maintenant un tableau qui contient par défaut les valeurs 0 {0,0,0,0,0,0}.
C’est pourquoi les valeurs qui sont affichées ne sont que des 0 mais pas les valeurs auxquelles tu t’attentais…

6)
pour afficher le tableau tab trié, ne fait pas comme tu l’as fait. En fait ce que tu fais, consiste à afficher le tableau à chaque etape c’est-à-dire pour chaque valeur de j. C’est quand même intéressant si tu veux voir comment le tableau est modifié à chaque etape. Par contre, si tu veux afficher les valeurs tab[i] du tableau trié , il faut une autre boucle for comme ceci:

Code:

---

1 2 3 4

for (int i=0;i<tailleTableau;i++){ System.out.println(tab[i]); }

---

Autant pour moi, j'aurai du écrire :

Code:

---

tmp = tab.clone();

---

:oops:

En fait, je cherche toujours a minimiser au maximum les modifications du code original...