C'est normal, à cause de la récurrence. La tête de la pile est en même temps la pile (l'adresse d'entrée dans la pile), donc on ne peut le supprimer. On peut éventuellement faire autrement...Envoyé par philippe123
C'est normal, à cause de la récurrence. La tête de la pile est en même temps la pile (l'adresse d'entrée dans la pile), donc on ne peut le supprimer. On peut éventuellement faire autrement...Envoyé par philippe123
hum... un tableau pour implémenter une pile ?
Pas bien.
mon sujet ne me le permet pas...
bon je rajoute un premier element de test alors?Envoyé par professeur
un sommet que j'aurais fixé
pile vide qui me renvoit true si nb element = 1
c'est un peu bourrin......
Non, je modifierais ta class Pile_entier:Envoyé par philippe123
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 public class Pile_entier { private int valeur; private Pile_entier suivant; public Pile_entier(int n){ valeur = n; } public Pile_entier(){ this(0);} // constructeur public void empiler(int n) { if(suivant == null){ suivant = new Pile_entier(n); } else{ suivant.empiler(n); } } public String toString(){ if(suivant == null){ return valeur + "\n";} else return suivant + "\n" + valeur; } public void depiler() { if(suivant == null){ return;} if(suivant.getSuivant() == null){ System.out.println("Dépiler : " + valeur); suivant = null; } else{ suivant.depiler(); } } public Pile_entier getSuivant(){return suivant;} public int getValeur(){return valeur;} }
Je rajouterais une classe englobante qui gère la pile vide ensuite:
Ensuite la classe principale...
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 public class Pile { private Pile_entier pile; private int taille; public Pile() { pile = null; taille = 0; } public void empiler(int n) { if(pile==null) pile = new Pile_entier(n); else pile.empiler(n); taille++; } public void depiler() { if(taille>0) { pile.depiler(); taille--; } if(taille==0) pile = null; } public String toString(){ if(pile==null) return "Pile est vide"; else return pile.toString(); } public int getTaille() { return taille; } public boolean estVide() { return getTaille()==0; } }
En plus, tu as maintenant la taille de la pile...
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10 public class Principale { public static void main(String[] args) { Pile maPile = new Pile(); //instanciation maPile.empiler(8); maPile.depiler(); System.out.println(maPile.getTaille()); } }
Il y a surement mieux mais je ne voulais pas tout changer,
Jc
merci pour ta solution. Elle m'a l'air judicieuse... mais mon sujet est precis et m'impose d'avoir qu'une et une seule classe.
La contrainte est qu'il veuille utiliser une seule classe pour la definition de la pile.
En plus, tu as maintenant la taille de la pile...
Il y a surement mieux mais je ne voulais pas tout changer,
Jc
A+[/quote][/code]
[Envoyé par professeur
Désolé, j'avais lu en diagonale...
Voilà une solution, fusionnant donc l'idée précédente et n'utilisant qu'une seule classe. Il y a par contre une variable statique...
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 public class Pile_entier { private int valeur; private Pile_entier suivant; private static int taille; public Pile_entier(int n){ valeur = n; taille = 1; } public Pile_entier(){} // constructeur public void empiler(int n) { if(taille==0) { valeur = n; taille++; } else if(suivant == null){ suivant = new Pile_entier(n); taille++; } else{ suivant.empiler(n); } } public String toString(){ if(suivant == null){ return valeur + "\n";} else return suivant + "\n" + valeur; } public void depiler() { if(taille>1) { if(suivant.getSuivant() == null){ System.out.println("Dépiler : " + valeur); suivant = null; taille--; } else{ suivant.depiler(); } } else taille--; } public Pile_entier getSuivant(){return suivant;} public int getTaille(){return taille;} public boolean estVide() {return taille==0;} /* On suppose que cette méthode n'est pas appelée si estVide()==true, un trycatch pourrait servir... */ public int getValeur(){return valeur;} }
c'est le meme pb qu'avec professeur
le depiler ne s'applique pas
mon main :
le retour de la console est toujours 8 ouis 8...
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10 public class Principale { public static void main(String[] args) { Pile_entier maPile = new Pile_entier(8); //instanciation System.out.println(maPile); maPile.depiler(); System.out.println(maPile); } }
Désolé, j'ai oublié de changer le toString:
Jc
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10 public String toString(){ if(taille==0) return "La pile est vide\n"; else if(suivant == null){ return valeur + "\n";} else return suivant + "\n" + valeur; }
8) merci beaucoup fearyourself ca marche bien et je vais pouvoir continuer à coder les autres procedures
merci encore et merci à tous le monde
@+
Teste ceci:
Programme principal:
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 class Pile { private Pile suivant; private int valeur; private bool vide = false; public Pile(int n) { valeur = n; } public bool estVide() { return vide; } public int consulter() //lire la valeur au dessus de la pile (différent de getValeur()) { if(estVide()) { System.out.println("La pile est vide"); return -1; } else if(suivant == null) { return valeur; } else { return suivant.consulter(); } } public void empiler(int n) { if(suivant == null) { suivant = new Pile(n); vide = false; } else suivant.empiler(n); } public void depiler() { if(suivant == null){ vide = true; return; } else if(suivant.getSuivant() == null) { System.out.println("Dépiler : " + suivant.getValeur()); suivant = null; } else { suivant.depiler(); } } public int getValeur() { return valeur; } public Pile getSuivant() { return suivant; } public String toString() { if(estVide()) { return "Warning : La pile est vide"; } else if(suivant == null) { return valeur + ""; } else{ return (suivant+ "\n" + valeur); } } }
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9 Pile p = new Pile(0); for(int i = 1; i < 21; i++) { if(i%2 == 0) p.depiler(); p.empiler(p.consulter() + 1); } System.out.println(p);
j'ai du mal à saisir ton code
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5 if(i%2 == 0) p.depiler(); p.empiler(p.consulter() + 1); }
C'est juste pour tester le programme. Il empile à chaque itération et il dépile une itération sur deux.Envoyé par philippe123
Jc
Bonjour tout le monde
Je fais actuellement le même exercice que Philippe mais en un peu plus complexe...
J'utilise d'autres classes et constructeurs que j'empile sous le même principe... Par exemple j'empile la classe Permis (au lieu des entiers):
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 public class Permis { private Mongars pers; private String cat; private Madate date; private String lieu; public Permis(Mongars p, String c, Madate d, String l) {this.pers=p; this.cat=c; this.date=d; this.lieu=l;} public void setpers(Mongars p) {this.pers=p;} public void setdate(Madate d) {this.date=d;} public void setcat(String c) {this.cat=c;} public void setlieu(String l) {this.lieu=l;} public Mongars getpers() {return pers;} public Madate getdate() {return date;} public String getcat() {return cat;} public String getlieu() {return lieu;} public String toString() {String s=pers.toString(); s += ""+ cat +""; s += date.toString(); s +=""+lieu; return s;} public void afficherpermis() { String s; s="Monsieur "+ pers.toString()+ " catégorie de permis : " + cat + " ne le " + date.toString() + " a " + lieu; System.out.println(s);} }
En faite, ce que je voudrais faire, c'est une recherche des attributs "Cat" et de la classe "Mongars", enfin je cherche à les récupérer...
Alors j'aurais aimer savoir si la seule manière de récupérer les attributs d'une classe se faisait dans le main ?(au moment de l'insertion des attributs) ou bien existe t il un moyen de les récuperer depuis la classe "Pile" ? Et si oui comment ?
Merci pour votre aide
salut alexino, tu devrais créé faire un autre post car cet exercice n'a rien à voir avec la pile d'entier avec une et une seule classe.Envoyé par Alexino2
Il est beaucoup plus facile car tu as la classe cellul qui possede valeur de type permis et suivant de type cellul.
Et puis la programmation objet consiste à quand tu créé un objet dans une classe tu peux apres apres acceder à ces methodes.
Donc si tu créé un objet pile ayant pour attribut "pers"; objet de la classe "MonGars", tu peux donc acceder à ses methodes donc acceder à son get et donc recuperer sa valeur...
bon courage...
rebonjour à tous
je n'arrive pas a coder une procedure qui irait verifier dans la pile si il y a 2 element ayant la meme valeur
on sortirait de cette procedure au premier doublon trouvé
ma classe pile_entier :
merci d'avance à tous pour vos reponses
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 public class Pile_entier { private int valeur; // valeur private Pile_entier suivant; // suivant private int taille_pile = 1; // taille de la pile public Pile_entier(int n){this.valeur = n;} // constructeur public int get_taille_pile() {return this.taille_pile;} //accesseur public int get_valeur() {return this.valeur;} //accesseur public Pile_entier get_suivant() {return this.suivant;} //accesseur public void set_taille_pile(int t) {this.taille_pile = t;} //accesseur public void set_valeur(int v) {this.valeur = v;} //accesseur public void empiler(int n) //empiler un element { if(this.get_taille_pile() == 0) this.set_valeur(n); else { if(this.get_suivant() == null) suivant = new Pile_entier(n); else suivant.empiler(n); } this.set_taille_pile(this.get_taille_pile()+1); } public void depiler() // depiler un element { if(this.get_suivant() != null) { if(this.get_suivant().get_suivant() == null) suivant = null; else suivant.depiler(); } else this.set_taille_pile(0); } public String toString() // affichage { if(this.get_taille_pile() != 0) { if(this.get_suivant() == null) return String.valueOf(this.get_valeur()); else return this.get_suivant() + " - "+this.get_valeur(); } else return "La pile est vide"; } public string doublon_pile() { } }
je viens de coder cette proc mais en utilisant un tableau
si kelkun voit mieux...
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 public String doublon() { String str_msg = "Pas de doublons"; Pile_entier p = this; boolean bool_stop = false; int cpt = 0; int max = this.get_taille_pile()-1; int tab_entier[] = new int[max+1]; while (cpt <= max) { tab_entier[cpt] = p.get_valeur(); p = p.get_suivant(); cpt++; } for (cpt = 0; cpt <= max; cpt++ ) { for (int cpt2 = 0; cpt2 <= max; cpt2++) { if (cpt != cpt2 && tab_entier[cpt] == tab_entier[cpt2]) { str_msg = "Doublon trouvé. valeur = "+String.valueOf(tab_entier[cpt]); cpt = max; cpt2 = max; } } } return str_msg; }
Si on part d'un point de vue algorithmique et donc complexité, ton algorithme est en n^2, or avec un quicksort et une recherche linéaire tu pourrais arriver à n*log(n)...
Il y a peut-être encore mieux mais c'est lundi matin alors...
Pour critiquer ta fonction:
Cette variable n'est pas utilisée...
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2 boolean bool_stop = false;
J'enleverais les inférieurs ou égaux (question de goût) et j'enlèverais les -1,+1 inutiles...
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4 int max = this.get_taille_pile()-1; int tab_entier[] = new int[max+1]; while (cpt <= max)
Ensuite ton choix de bornes pour tes boucles n'est pas optimal, tu pourrais faire ceci, (je conserve ma valeur de max et cpt2, je la déclare au début de la fonction...):
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4 int maix = this.get_taille_pile(); int tab_entier[] = new int[max]; while(cpt<max)
Voilà,
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 for (cpt = 0; cpt < max; cpt++ ) { for (cpt2 = cpt+1; cpt2 < max; cpt2++) { if (tab_entier[cpt] == tab_entier[cpt2]) { str_msg = "Doublon trouvé. valeur = "+String.valueOf(tab_entier[cpt]); cpt = max; cpt2 = max; } } } return str_msg; }
Jc
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 public String doublon_dans_pile() // affiche s'il y a un doublon dans la pile { String str_msg = "Pas de doublons"; Pile_entier p = this; int tab_entier[] = new int[this.taille]; int cpt = 0; while (cpt < this.taille) { tab_entier[cpt] = p.valeur; p = p.suivant; cpt++; } for (cpt=0; cpt<(this.taille-1); cpt++) { for (int cpt2=(cpt+1); cpt2<this.taille; cpt2++) { if (tab_entier[cpt] == tab_entier[cpt2]) { str_msg = "Doublon trouvé. valeur = "+String.valueOf(tab_entier[cpt]); cpt = cpt2 = this.taille; } } } return str_msg; }
Vous avez un bloqueur de publicités installé.
Le Club Developpez.com n'affiche que des publicités IT, discrètes et non intrusives.
Afin que nous puissions continuer à vous fournir gratuitement du contenu de qualité, merci de nous soutenir en désactivant votre bloqueur de publicités sur Developpez.com.
Partager