problème boucle en java Fermé

Question

Bonjour, je débute en java et je commence à travailler avec les tableaux et j'essaie d'écrire un programme qui va trier 5 mots en ordre croissant.

J'ai un problème avec ma boucle while

while(listeMots[0].compareTo(listeMots[1]) > 0 && listeMots[1].compareTo(listeMots[2]) > 0  && listeMots[2].compareTo(listeMots[3]) > 0  && listeMots[3].compareTo(listeMots[4]) > 0)

dès qu'une seule de ses conditions est réuni, la boucle s'arrêtte alors que je veux qu'elle s'arrêtte seulement quand toute les conditions sont réunis, donc quand tous les mots sont bien en ordre croissant dans le tableau. 

Pourtant avec des Et c'est ce que s'est censé faire, je ne comprend pas



Configuration: Windows 8 / Internet Explorer 10.0



Configuration: Windows 8 / Internet Explorer 10.0

nicocorico · Answer

Hum, à mon avis tu as juste un problèmes avec les parenthèses, il faut en mettre pour définir chaque terme proprement:

while((listeMots[0].compareTo(listeMots[1]) > 0) && (listeMots[1].compareTo(listeMots[2]) > 0)  && (listeMots[2].compareTo(listeMots[3]) > 0)  && (listeMots[3].compareTo(listeMots[4]) > 0))

KX · Answer

Il faut inverser ta condition, pour qu'elle continue si elle est vraie et s'arrête quand elle est fausse. while( ! (listeMots[0].compareTo(listeMots[1]) > 0 && listeMots[1].compareTo(listeMots[2]) > 0 && listeMots[2].compareTo(listeMots[3]) > 0 && listeMots[3].compareTo(listeMots[4]) > 0)) En logique booléenne, cette négation de conjonction est équivalente à une disjonction de négation, ce qui rend la condition d'arrêt un peu plus explicite : while(listeMots[0].compareTo(listeMots[1]) <= 0 || listeMots[1].compareTo(listeMots[2]) <= 0 || listeMots[2].compareTo(listeMots[3]) <= 0 || listeMots[3].compareTo(listeMots[4]) <= 0) Remarque 1 : attention à bien prendre en compte les cas d'égalité, parce qu'il faut que ta boucle s'arrête dans tous les cas (si tu as deux mots identiques, tu n'auras jamais l'un qui sera strictement supérieur à l'autre). Remarque 2 : il me semble que cette condition va te renvoyer un ordre décroissant, pour un ordre croissant il faut faire l'inverse. while(listeMots[0].compareTo(listeMots[1]) > 0 || listeMots[1].compareTo(listeMots[2]) > 0 || listeMots[2].compareTo(listeMots[3]) > 0 || listeMots[3].compareTo(listeMots[4]) > 0)

Balthazar2 · Answer

Salut, je ne veux pas contredire, car je ne suis surement pas aussi connaissant que vous, mais si je met <= 0 au lieu de >=0 la condition sera fausse dès le début et je n'entrerai jamais dans la boucle non ? Sinon, je n'ai peut-être pas la meilleure technique, mais j'ai une variable plusPetitMot que j'initialise à un truc du genre "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz" avant mon while, plusPetitNombre prend la valeur du mot en première position. ce que je fais c'est que j'ai une boucle for a l'intérieur du while qui va se charger de trouver le plus petit nombre qui sera placer ensuite en première position, ce qui me pose problème, car je viens de me rendre compte que j'écrase la première position du tableau par la valeur de plusPetitMot au lieu de permuter plusPetitMot avec la position du premier mot que j'ai entrer. J'ai chercher et la bonne technique consiste a passer par une variable temporaire, mais le soucis c'est que je ne sais pas d'avance le mot qui sera permuter. ensuite plusPetitNombre prend la valeur du deuxieme élément du tableau et je dois revenir dans le for pour trouver le deuxieme plus petit et ainsi de suite. ça me donne quelque chose comme ça. plusPetitNombre a la valeur du premier élément du tableau au début de la boucle. int i=0; int j=0; int k=4; while(listeMots[0].compareTo(listeMots[1]) >= 0 && listeMots[1].compareTo (listeMots[2]) >= 0 && listeMots[2].compareTo(listeMots[3]) >= 0 && listeMots[3].compareTo(listeMots[4]) >= 0) { for(j=0;j0) plusPetitMot = listeMots[j+1]; } //permuter plusPetitMot avec listeMots[i] plusPetitMot = listeMots[i+1]; i++; k--; } Le truc c'est que dès qu'une des 4 condition est fausse, la boucle while prend fin, ce que je ne comprend pas Par exemple si j'entre les mots dans cet ordre : tomate patate concombre carotte asperge chaque mot est > que le précédent donc toute els conditions sont vrai. Comme j'écrase tomate par plusPetitMot, le tableau se compose ensuite comme ceci après un premier tour de boucle asperge patate concombre carotte asperge la première condition est fausse, fin de la boucle, alors que je veux qu'elle s'arrête seulement quand chaque élément du vecteur < que le précédent si j'entre les mot dans cet ordre : tomate asperge concombre carotte patate je n'entre même pas dans ma boucle while, première condition vrai, mais la seconde fausse, fin de la boucle. Il y a donc clairement un problème dans les conditions que j'ai mis dans le while que je n'arrive pas à identifier.

Balthazar2 · Answer

Effectivement il fallait des ou, j'ai lu un peu vite :s



Je pourrais aussi initialiser mon plusPetitMot à "" et lui donner la valeur de listeMots[0]; juste avat mes boucle de tri.

J'avoue avoir du mal à savoir quelle façon de faire est la plus opti, mais j'ai un peu changer ma façon de faire, car je n'arrivais pas à savoir d'avance quelle était l'indice du plus petit mot dans le tableau listeMots.

Je me suis fais un deuxième tableau qui lui contiendra les valeurs en ordre croissant, la boucle continue tant qu'il n'est pas rempli.

Mais difficile d'optimiser le tri, car inutile de comparer les autre mot avec un mot qui a été placé dans le tableau croissant[] et il ne faut non plus. Par exemple dans mon exemple asperge est le plus petit, au second tour de boucle for, il ne doit plus faire parti du tri. Et je ne dois pas non plus comparer un mot avec lui même.

Mais qu'entend tu par test à rallonge ?

Balthazar2 · Answer

La technique que je connais pour permuter 2 éléments c'est quelque chose comme ça 

temp = tab[0]; 
tab[0] = tab[1]; 
tab[1] = temp; 

Mais dans ma boucle for  


for(j=0;j<k;j++)  
               {  
                         if(plusPetitMot.compareTo(listeMots[j+1] >0)  
                                plusPetitMot = listeMots[j+1];   
               }  




Je sais que la boucle for doit chercher les éléments à permuter, mais comment faire pour que la boucle trouve la position du mot le plus petit dans le tableau listeMot[], c'est là que je bloque.

temp = listeMots[i];
listeMots[i] = plusPetitMots;
??? = temp;

Balthazar2 · Answer

Disons que je trouvais intéressant de permuter seulement quand le plus petit mot de la liste a été trouver.  

J'essayais de trouver le plus petit mot et de le permuter avec le mot en première position. le deuxième avec celui en deuxième position et ainsi de suite.

Balthazar2 · Answer

Salut, désolé du retard.

Mais merci de tes conseils ça m'a beaucoup aider. Tu dois penser que je suis un noob surtout avec ma toute première question XD

Problème boucle en java

7 réponses

Discussions similaires