Tour Hanoi avec piles

Bonjour a tous,
Apparemment tout fonctionne mais dans le menu si j appuie sur l options 4 il y a un message d erreur.
Quelqu un peut til m aider a trouver l erreur de mon programme.
Merci d avance

Classe ToursHanoi :

Code:

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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
public class ToursHanoi 
{	
	private Tour tours[] = new Tour[3];
	private int nb_anneaux;
	private int nb_deplacements;
	private int DA;
	private int DB;
	private int DC;
 
	// Constructeur
	public ToursHanoi(int nb_anneaux)
	{
		this.nb_anneaux = nb_anneaux;
		this.tours[0] = new Tour(nb_anneaux, 'A');
		this.tours[1] = new Tour(nb_anneaux, 'B');
		this.tours[2] = new Tour(nb_anneaux, 'C');
 
		reinitialiser();
	}
 
	//Accesseurs
	public Tour getTourA()
	{
		return this.tours[0];
	}
 
	public Tour getTourB()
	{
		return this.tours[1];
	}
 
	public Tour getTourC()
	{
		return this.tours[2];
	}
 
	//Méthode permettant de vider les tours et de remplir la tour A
	public void reinitialiser()
	{
		this.getTourA().vider();
		this.getTourB().vider();
		this.getTourC().vider();
		this.nb_deplacements = 0;
		this.getTourA().AjoutAnneaux(new Anneau[nb_anneaux]);
	}
 
	public boolean Deplacer(char de,char vers)
	{
 
		de = Character.toUpperCase(de);
		vers = Character.toUpperCase(vers);
 
 
		DA = this.tours[0].peek().getDiametre();
		if(!this.tours[1].isEmpty())
			DB = this.tours[1].peek().getDiametre();
		else
			if(!this.tours[2].isEmpty())
				DC = this.tours[2].peek().getDiametre();
 
		if (de == 'A')
		{
			if(vers == 'B')
			{		
				if (DA>DB)
				{
					System.out.println("Deplacement Illegal!");
					return false;
				}
				else
				{
					this.tours[1].push(this.tours[0].pop());
 
 
					System.out.println("L'anneau de diamètre "+ 1 + " est déplacé de la tour A vers la tour B");
					nb_deplacements++;
					return true;
				}
			}
			else
			{
				if (DA > DC)
				{
					System.out.println("Deplacement Illegal");
					return false;
				}
				else
				{
					this.tours[2].push(this.tours[0].pop());
 
 
					System.out.println("L'anneau de diamètre "+ "1" + " est déplacé de la tour A vers la tour C");
					nb_deplacements++;
					return true;
				}
 
			}
		}
		else
		{	
			if(de == 'B')
			{
				if(vers == 'A')
				{
					if (DB>DA)
					{
						System.out.println("Deplacement Illegal");
						return false;
					}
					else
					{
						this.tours[0].push(	this.tours[1].pop());
 
 
						System.out.println("L'anneau de diamètre "+ "2" + " est déplacé de la tour B vers la tour A");
						nb_deplacements++;
						return true;
					}
				}
				else
				{
 
					if (DB>DC)
					{
						System.out.println("Deplacement Illegal");
						return false;
					}
					else
					{
						this.tours[2].push(this.tours[1].pop());
 
 
						System.out.println("L'anneau de diamètre "+ "1" + " est déplacé de la tour B vers la tour C");
						nb_deplacements++;
						return true;
					}
				}
			}
			else 
			{
				if(vers == 'A')
				{
					if (DC>DA)
					{
						System.out.println("Deplacement Illegal");
						return false;
					}
					else
					{
						this.tours[0].push(this.tours[2].pop());
 
 
						System.out.println("L'anneau de diamètre "+ "2" + " est déplacé de la tour C vers la tour A");
						nb_deplacements++;
						return true;
					}
				}
				else
				{
					if (DC>DB)
					{
						System.out.println("Deplacement Illegal");
						return false;
					}
					else
					{
						this.tours[1].push(this.tours[2].pop());
 
 
						System.out.println("L'anneau de diamètre "+ "1" + " est déplacé de la tour C vers la tour B");
						nb_deplacements++;
						return true;
					}
				}
			}
		}
	}
 
	public void DeplacerAuto(int nb_anneaux, char de, char milieu, char vers)
	{
		//S'il n'y a qu'un seul anneau dans la tour A
		if(nb_anneaux==1)
		{
			Deplacer(de,vers);
			nb_deplacements++;
 
		}
		else
		{
			DeplacerAuto(nb_anneaux-1, de, vers, milieu);
			nb_deplacements++;
			Deplacer(de,vers);
			nb_deplacements++;
			DeplacerAuto(nb_anneaux-1, milieu, de, vers);
			nb_deplacements++;
 
			this.getTourA().toString();
			this.getTourB().toString();
			this.getTourC().toString();
		}
	}
 
	public void resoudre()
	{
		reinitialiser();
		DeplacerAuto(this.nb_anneaux, 'A','B','C');
 
	}
 
	// Méthode pour trouver la tour
	public Tour Convertion( char rep)
	{
		int elt=0;
		if (rep=='A')
			elt=0;
		if(rep=='B')
			elt=1;
		if(rep=='C')
			elt=2;
		return tours[elt];
	}
 
	// Afficher les tours
	public String toString()
	{
		return this.getTourA().toString()+ this.getTourB().toString()+ this.getTourC().toString() ;
	}
 
 
 
}

Classe Tour :

Code:

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
public class Tour 
{
 
	private Anneau[] pile;// pile d'anneaux
	private int taille;// pour le nombre maximum d'anneaux
	private char alias;// pour gérer l'alias
	private int top;
 
	//Constructeur
	public Tour(int taille, char alias)
	{
		this.taille = taille;
		this.alias = alias;
		this.pile = new Anneau[taille];
		top = -1;// pointeur pour parcourir la pile
	}
 
	//Accesseurs
	public char alias()
	{
		return this.alias;
	}
 
	//Accesseurs
 
 
	//Opérations primaires et secondaires
	public void push(Anneau anneau)
	{
		if(!isFull())
			this.pile[++top] = anneau;
	}
 
	public Anneau pop()
	{
		if(!isEmpty())
			return pile[top--];
		return null;
	}
 
	public Anneau peek()
	{
		return pile[top];
	}
 
	public boolean isEmpty()
	{
		return top == -1;
	}
 
	public boolean isFull()
	{
		return (top == pile.length - 1);
	}
 
	//Méthode permettant de vider la pile
	// Méthode vider
	public void vider()
	{
		top=-1;
	}
 
	public Anneau[] getPile(int n) {
		return new Anneau[n];
	}
 
	public void setPile(Anneau[] pile) {
		this.pile = pile;
	}
 
	// Méthode qui met les anneaux sur la tour
	public void AjoutAnneaux(Anneau[] pile)
	{
		setPile(pile);
		for(int i=0;i<pile.length;i++)
		{
			this.pile[i]=new Anneau(pile.length-i);
			this.push(this.pile[i]);
		}
	}
 
	//Redéfinition méthode toString
	public String toString()
	{
		String temp = new String();
		temp ="\n"+(this.alias+": ");
 
		for(int j=0; j<taille;j++)
		{
			if (this.pile[j]==null)
			{
				temp += "-";
			}
			else
			{
				temp +=this.pile[j].getDiametre();
			}
		}
		return temp;
	}
}

Classe Anneau :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Anneau 
{
 
	private final int diametre;
 
	public Anneau(int diametre){
 
		this.diametre = diametre;
 
	}
 
	public int getDiametre(){
		return this.diametre;
	}
}

Classe Main :

Code:

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
import java.io.*;
 
public class Main {
 
	//Méthode principale
	public static void main(String[] args) throws IOException
	{
		System.out.println("-- Jeu des tours d'Hanoi --");
		ToursHanoi partie = new ToursHanoi(3);
		int choix = -1;
		int nb_anneaux;
 
		System.out.println(partie);
 
		do
		{
			choix = MenuPrincipal();
 
			switch(choix)
			{
			case 1: //Déterminer le nombre d'anneaux (3 par défaut)
			{
				do
				{
					System.out.println("Entrer le nombre d'anneaux (entre 1 et 9 inclusivement).\n " +
							"Entrer 0 pour retourner au menu principal.");
					nb_anneaux = getInt();
 
				}while(nb_anneaux <= 0 || nb_anneaux >= 9);
 
				if (nb_anneaux != 0)
					partie = new ToursHanoi(nb_anneaux);
				System.out.println(partie);
				break;				
			}
 
			case 2: //Réinitialiser les tours
			{
				partie.reinitialiser();	
				System.out.println(partie);
				break;
			}
 
			case 3: //Jouer un coup
			{
				//Deplacer est une méthode dans ToursHanoi
				partie.Deplacer(position_de(), position_vers());
				System.out.println(partie);
				break;
			}
 
			case 4: //Montrer la solution
			{
				//Resoudre est une méthode dans ToursHanoi
				partie.resoudre();
				break;					
			}
 
			case 5: //Quitter
			{
				break;
			}
 
 
			default:
				System.out.println("\nChoix invalide! Veuillez recommencer.");
				break;
 
			}
 
		}while (choix != 5);
 
	}
 
	public static char position_de() throws IOException
	{
		System.out.print("Quelle tour souhaitez‐vous déplacer un anneau? (A ou B ou C): ");
		return getChar();
	}
 
	public static char position_vers() throws IOException
	{
		System.out.print("Vers quelle tour?");
		return getChar();
	}
 
	//Menu principal
	public static int MenuPrincipal() throws IOException
	{
		System.out.println("\n[MENU]");
		System.out.println("1: Déterminer le nombre d'anneaux (3 par défaut)");
		System.out.println("2: Réinitialiser les tours");
		System.out.println("3: Jouer un coup");
		System.out.println("4: Montrer la solution");
		System.out.println("5: Quitter");
		System.out.println("Faites votre choix et appuyer sur ENTER");
		return getInt();
	}
 
	public static int getInt() throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		return Integer.parseInt(br.readLine());	
	}
 
	public static char getChar() throws IOException 
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));	      
		return br.readLine().charAt(0);
	}
 
}

Bonjour,

Dans des balies code sa ferai plus lisible ^_^°, le # au dessus quand tu écris un message.

Vu le nombre de class et de ligne il serait intéressant d'avoir le message d'erreur parce que pour ma part je n'ai pas un compilateur intégré :p.

Citation:

Exception in thread "main" java.lang.NullPointerException
at ToursHanoi.Deplacer(ToursHanoi.java:56)
at ToursHanoi.DeplacerAuto(ToursHanoi.java:193)
at ToursHanoi.resoudre(ToursHanoi.java:207)
at Main.main(Main.java:55)

L'erreur vient du fait qu'a la ligne :

Code:

DB = this.tours[1].peek().getDiametre();

Code:

this.tours[1].peek()

est NULL.

Il te manque un test OU alors tu as oublier de remplir la pile quelque part.

Il te manquait juste le test "Un déplacement est légal si une tour est vide" :

Code:

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
public boolean Deplacer(char de, char vers) {
      int DA = 0;
      int DB = 0;
      int DC = 0;
 
      de = Character.toUpperCase(de);
      vers = Character.toUpperCase(vers);
 
      if (!this.tours[0].isEmpty())
        DA = this.tours[0].peek().getDiametre();
      if (!this.tours[1].isEmpty())
        DB = this.tours[1].peek().getDiametre();
      if (!this.tours[2].isEmpty())
        DC = this.tours[2].peek().getDiametre();
 
      if (de == 'A') {
        if (vers == 'B') {
          if (DA > DB && DB != 0) {
            System.out.println("Deplacement Illegal!");
            return false;
          }
          else {
            this.tours[1].push(this.tours[0].pop());
 
            System.out.println("L'anneau de diamètre " + DA + " est déplacé de la tour A vers la tour B");
            nb_deplacements++;
            return true;
          }
        }
        else {
          if (DA > DC && DC != 0) {
            System.out.println("Deplacement Illegal");
            return false;
          }
          else {
            this.tours[2].push(this.tours[0].pop());
 
            System.out.println("L'anneau de diamètre " + DA + " est déplacé de la tour A vers la tour C");
            nb_deplacements++;
            return true;
          }
 
        }
      }
      else {
        if (de == 'B') {
          if (vers == 'A') {
            if (DB > DA && DA != 0) {
              System.out.println("Deplacement Illegal");
              return false;
            }
            else {
              this.tours[0].push(this.tours[1].pop());
 
              System.out.println("L'anneau de diamètre " + DB + " est déplacé de la tour B vers la tour A");
              nb_deplacements++;
              return true;
            }
          }
          else {
 
            if (DB > DC && DC != 0) {
              System.out.println("Deplacement Illegal");
              return false;
            }
            else {
              this.tours[2].push(this.tours[1].pop());
 
              System.out.println("L'anneau de diamètre " + DB + " est déplacé de la tour B vers la tour C");
              nb_deplacements++;
              return true;
            }
          }
        }
        else {
          if (vers == 'A') {
            if (DC > DA && DA != 0) {
              System.out.println("Deplacement Illegal");
              return false;
            }
            else {
              this.tours[0].push(this.tours[2].pop());
 
              System.out.println("L'anneau de diamètre " + DC + " est déplacé de la tour C vers la tour A");
              nb_deplacements++;
              return true;
            }
          }
          else {
            if (DC > DB && DB != 0) {
              System.out.println("Deplacement Illegal");
              return false;
            }
            else {
              this.tours[1].push(this.tours[2].pop());
 
              System.out.println("L'anneau de diamètre " + DC + " est déplacé de la tour C vers la tour B");
              nb_deplacements++;
              return true;
            }
          }
        }
      }
    }