Discussion :

[professeur]

Code :

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

1
2
3
4
5
6
7
8
9
public class Principale 
{
	public static void main(String[] args)
	{
		Pile_entier maPile = new Pile_entier(8); //instanciation
		maPile.depiler();
		System.out.println(maPile.getValeur());
	}
}

voici mon main et retour est 8 donc il a pas depiler

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...

[White Rabbit]

hum... un tableau pour implémenter une pile ?

Pas bien.

[philippe123]

mon sujet ne me le permet pas...

[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...

bon je rajoute un premier element de test alors?
un sommet que j'aurais fixé
pile vide qui me renvoit true si nb element = 1

c'est un peu bourrin......

[fearyourself]

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...

bon je rajoute un premier element de test alors?
c'est un peu bourrin......

Non, je modifierais ta class Pile_entier:

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:

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;
  }
 
}

Ensuite la classe principale...

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());
   }
}

En plus, tu as maintenant la taille de la pile...

Il y a surement mieux mais je ne voulais pas tout changer,
Jc

[philippe123]

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.

[professeur]

En plus, tu as maintenant la taille de la pile...

Il y a surement mieux mais je ne voulais pas tout changer,
Jc

La contrainte est qu'il veuille utiliser une seule classe pour la definition de la pile.

A+[/quote][/code]

[fearyourself]

La contrainte est qu'il veuille utiliser une seule classe pour la definition de la pile.

A+

[

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;}
}

[philippe123]

c'est le meme pb qu'avec professeur
le depiler ne s'applique pas

mon main :

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);
	}
}

le retour de la console est toujours 8 ouis 8...

[fearyourself]

Désolé, j'ai oublié de changer le toString:

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;
   }

Jc

[philippe123]

8) merci beaucoup fearyourself ca marche bien et je vais pouvoir continuer à coder les autres procedures

merci encore et merci à tous le monde
@+

[professeur]

Teste ceci:

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);
 
			} 
		}
	}

Programme principal:

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);

[philippe123]

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); 
}

j'ai du mal à saisir ton code

[fearyourself]

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); 
}

j'ai du mal à saisir ton code

C'est juste pour tester le programme. Il empile à chaque itération et il dépile une itération sur deux.

Jc

[Alexino2]

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

[philippe123]

Bonjour tout le monde

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.
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...

[philippe123]

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 :

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()
   {
 
   }
}

merci d'avance à tous pour vos reponses

[philippe123]

je viens de coder cette proc mais en utilisant un tableau

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 kelkun voit mieux...

[fearyourself]

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:

Code :

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

1
2
 
	boolean bool_stop = false;

Cette variable n'est pas utilisée...

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)

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 maix = this.get_taille_pile();
   int tab_entier[] = new int[max];
   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
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;   
  }

Voilà,
Jc

[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
   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;   
  }

merci @+