Discussion :

[Adenora]

Bonjour,

J'ai un soucis au niveau de l'affichage d'une structure de données.
(Voir le code ci-dessous)

On doit créer une méthode affiche() qui affiche dans l'ordre la totalité des chaînes contenues dans la structure Curseur. L'utilisation préalable de gauche() ou droite() ne doit pas changer l'effet de cette méthode.

Je vais tenter de m'expliquer.
A savoir que dans le code, j'utilise dans l'ordre, la méthode affD(), puis affiche(), puis affD().
Je n'obtiens pas la même chose avant et après affiche(), avec la méthode affD(). Et après, j'utilise les méthodes gauche() et affD(), et là j'ai le droit à un affichage en boucle.

Par contre, si j'enlève affiche(), je n'ai pas de soucis.

Donc je pense que c'est évident, il y a un soucis dans ma méthode affiche(). Mais je me creuse la tête depuis un certain moment, et je n'arrive pas à trouver mon erreur.

En espérant avoir été précise dans mon explication.
Merci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
import java.util.Scanner;
 
 
public class curseur {
	private class chainage {
			String elt;
			chainage suiv;
	}
	chainage avant;
	chainage apres;
 
	curseur() {
		avant=null;
		apres=null;
	}
 
	public void droite() {
		chainage aux=apres;
		apres=apres.suiv;
		aux.suiv=avant;
		avant=aux;
	}
 
	public void gauche() {
		chainage aux=avant;
		avant=avant.suiv;
		aux.suiv=apres;
		apres=aux;
	}
 
	public void affD() {
		chainage aux=apres;
		while (aux!=null) {
			System.out.print(aux.elt);
			aux=aux.suiv;
		}
		System.out.println();
	}
 
	public void insert (String s) {
		chainage aux=new chainage();
		aux.elt=s;
		aux.suiv=avant;
		avant=aux;
	}
 
	public void delete() {
		avant=avant.suiv;
	}
 
	public void affiche() {
		chainage a=avant;
		chainage b=apres;
		chainage aux = new chainage();
		while (b!=null) {
			aux=b;
			b=b.suiv;
			aux.suiv=a;
			a=aux;
		}
		while (a!=null) {
			System.out.print(a.elt);
			a=a.suiv;
		}
		System.out.println();
	}
 
	public static void main (String args[]) {
		Scanner scan=new Scanner(System.in);
		curseur c = new curseur();
		c.insert("Ra");
		c.insert("Ta");
		c.gauche();
		System.out.print("Avant affichage :");
		c.affD();
		System.out.print("Affiche : ");
		c.affiche();
		System.out.print("Après affichage :");
		c.affD();
		c.gauche();
		System.out.print("Appuyez sur une touche et sur entrée");
		scan.next();
		c.affD();
		/*scan.next();
		System.out.print("Affiche : ");
		c.affiche();
		scan.next();
		c.droite();
		c.affD();
		System.out.print("Affiche : ");
		c.affiche();
		scan.next();
		c.delete();
		c.affD();
		System.out.print("Affiche : ");
		c.affiche();
		scan.next();
		c.droite();
		c.affD();
		System.out.print("Affiche : ");
		c.affiche();
		scan.next();
		c.insert("pis");
		c.gauche();
		c.affD();
		System.out.print("Affiche : ");
		c.affiche();
		scan.next();
		c.gauche();
		c.affD();
		System.out.print("Affiche : ");
		c.affiche();*/
	}
}

[jcdentons]

Bonjour,


Si je comprends bien la logique, quand vous allez vers la droite, après devient son suivant et avant devient après.

A quoi servent les lignes en rouge ci-dessous ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
public void droite() {
		chainage aux=apres;
		apres=apres.suiv;
		aux.suiv=avant;
		avant=aux;
	}
	
public void gauche() {
		chainage aux=avant;
		avant=avant.suiv;
		aux.suiv=apres;
		apres=aux;
	}

[Adenora]

Je ne saurais pas expliquer, puisque c'est le code qu'on nous a fourni.
J'ai été obligée de faire des tests pour comprendre le fonctionnement de ces deux méthodes.

[LittleBean]

Comme jcdentons l'a indiqué les méthodes droites/gauches sont curieuses .... mais si c'est du code fourni à ne pas toucher

Alors la constatation est qu'il est possible de créer un cycle avec ta classe chainage (méthodes gauche/droite) ... et donc ton test dans ton while n'est pas bon :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

while (b!=null)

tu dois stocker les éléments déjà affichés et faire un test si il n'a pas déjà été affiché.

[Adenora]

qu'il est possible de créer un cycle avec ta classe chainage (méthodes gauche/droite)

Comme déjà les deux méthodes sont bizarres, j'ai un peu de mal à construire la méthode affiche.

En gros,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
while (b!=null) {
	aux=b;
	b=b.suiv;
	aux.suiv=a;
	a=aux;
}

Ici, je mets tous les éléments dans a (avant) jusqu'à ce que b (après) soit vide.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
while (a!=null) {
	System.out.print(a.elt);
	a=a.suiv;
}

Et ici, j'affiche tous les éléments de a.

Et au moment de l'affichage, je fais dans l'ordre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
System.out.print("Avant affichage :");
c.affD();
System.out.print("Affiche : ");
c.affiche();
System.out.print("Après affichage :");
c.affD();

Ce qui donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Avant affichage :Ta // Affichage de "apres" avec méthode affD
Affiche : TaRa // Affichage de la structure de données
Après affichage :TaRa // Affichage de "apres" avec méthode affD

On voit clairement que "avant" et "apres" ont été modifiés après la méthode ou pendant la méthode affiche. Je ne vois pas comment cela peut être possible.

Et un peu plus loin, j'ai le droit à un affichage en boucle.

[jcdentons]

En fait, vous modifiez votre structure à ce niveau là (en rouge) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
	
	public void affiche() {
		chainage a=avant;
		chainage b=apres;
		chainage aux = new chainage();
		while (b!=null) {
			aux=b;
			b=b.suiv;
			aux.suiv=a;
			a=aux;
		}
		while (a!=null) {
			System.out.print(a.elt);
			a=a.suiv;
		}
		System.out.println();
	}

Cela revient à faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

apres.suiv = avant;

, ce qui modifie donc avant et apres, non ?

Pour l'affichage, je ferai quelquechose du genre (comme pour affD) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
chainage aux = avant;
while (aux != null) {
	System.out.print(aux.elt);
	aux = aux.suiv;
}
aux = apres;
while (aux != null) {
	System.out.print(aux.elt);
	aux = aux.suiv;
}
System.out.println();

Est-ce ce que vous attendez ?
Je n'ai pas pu tester correctement, mais je vous conseille de tester en ajoutant plus de deux valeurs ...
Y a-t-il un ordre à respecter ?

[Adenora]

Je viens de tester et apparemment, ça l'air de fonctionner comme il faudrait.
Je me suis compliquée la vie pour rien.

Mais ce qui me semble bizarre c'est la ligne rouge. Pourquoi modifie-t-elle avant et apres ? Il n'y a pourtant pas de pointeurs en Java (au vu de ce qu'on m'a appris) ?

(A savoir que ce sujet était un sujet d'examen qui revient assez souvent)

[Adenora]

Euh ?

Bref, avant de m'endormir hier soir, je me suis dit, c'est normal que ça fonctionne, dans le jeu de test qu'on nous propose, on n'utilise que deux valeurs. Par contre, avec plus de deux, ça fonctionne plus.

Je fais exprès de stocker "avant" dans une variable auxiliaire pour éviter d'avoir des soucis, et j'ai des soucis quand même.

J'ai refait la méthode qui fonctionne maintenant, mais elle ne prend pas en compte la complexité (un peu le but du module) et je trouve que le code est "barbare" :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public void affiche() {
	int i=0;
	chainage aux=apres;
	// Tout dans apres
	while (avant!=null) {
		aux=avant;
		avant=avant.suiv;
		aux.suiv=apres;
		apres=aux;
		i++;
	}
	aux=apres;
	// On affiche les éléments contenus dans apres
	while (aux!=null) {
		System.out.print(aux.elt);
		aux=aux.suiv;
	}
	System.out.println();
	// On remet tout comme avant
	while (i!=0) {
		aux=apres;
		apres=apres.suiv;
		aux.suiv=avant;
		avant=aux;
		i--;
	}
}

[jcdentons]

Je viens de tester et apparemment, ça l'air de fonctionner comme il faudrait.
Je me suis compliquée la vie pour rien.

Mais ce qui me semble bizarre c'est la ligne rouge. Pourquoi modifie-t-elle avant et apres ? Il n'y a pourtant pas de pointeurs en Java (au vu de ce qu'on m'a appris) ?

(A savoir que ce sujet était un sujet d'examen qui revient assez souvent)

En fait, il ne s'agit pas de pointeur, mais de champs dans une classe.
Je vais vous donner un exemple simplifié :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
class A {
  int donnee;
  public static void main() {
    A var1, var2;
    var1 = new A();
    var1.donnee = 1;
    System.out.println(var1.donnee);
    //Affiche : 1
    var2 = var1;
    System.out.println(var2.donnee);
    //Affiche : 1
    var2.donnee = 2;
    System.out.println(var2.donnee);
    //Affiche : 2
    System.out.println(var1.donnee);
    //Affiche : 2 et pas 1!!
  }
}

Dans cet exemple bidon, après avoir fait "var2=var1", je n'ai plus modifié var1, ni var2. J'ai modifié l'objet référencé par var1 et var2, via var2.

Bref, tout ça pour dire que lorsque vous faites :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
aux=avant;
avant=avant.suiv;
aux.suiv=apres;

vous modifiez l'objet référencé par aux, c'est à dire l'objet qui était référencé par avant.
Pour tester, c'est simple, il suffit de tracer (via des System.out, ou bien de préférence via un debugguer en mode pas à pas : Eclipse est très bon pour ça).