Discussion :

[mroudy]

Bonjour et tous mes voeux,
J'ai un léger souci.
J'ai deux codes pour créer une pile et la modifier tout ceci version tableau.
Mon premier code donne une taille de tableau fixe.
Le second code permet de définir des entiers compris entre 0 et 99.
J'essaye de faire un mix de ces deux codes sachant que dans mon main on définit la taille du tableau, le but étant d'avoir un tableau d'entiers tirès aléatoirement, puis d'effectuer différentes opérations sur ce dernier. Bref, je n'arrive pas à faire un mix de ces deux classes.

Mon code de base.

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
 
package Pile;
 
public class PileTab {
 
 
 
private int tailleMax = 1000;   // Taille maximale
private int sommet = -1;        // Sommet du tableau
private int[] tableau;
 
// Constructeur: crée une pile vide de taille maximale donnée
public PileTab(int max) {
    tailleMax = max;
    sommet = -1;
    tableau = new int [tailleMax];
}
 
// Modificateurs
 
/** Effacer tous les elements   */
public void effacer() {
    sommet = -1;
}
 
/** Empiler */
public void empiler(int element) {
    if (sommet == tailleMax - 1) {
        System.out.println("Impossible d'empiler: la pile est pleine");
 
    }
 
    sommet++;
    tableau[sommet] = element;
}
 
/** Dépiler */
public void depiler() {
    if (isPileVide()) {
        System.out.println("Impossible de desempiler: la pile est vide");
    }
 
    sommet--;
}
 
// Sélecteurs
 
/** Teste si une pile est vide */
public boolean isPileVide() {
    return (sommet == -1);
}
 
/** Retourne la valeur du sommet */
public int sommet() {
    if (isPileVide()) {
        System.out.println("Impossible de donner la valeur du sommet: la pile est vide");
 
    }
 
    return tableau[sommet];
}
 
}

Code pour le choix aléatoire des valeurs des entiers dans le 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
 
 
public class Tableau
{
	int [] tab;
 
	//Constructeur
	Tableau(int n)
	{		
		Random rand = new Random();						
 
		tab  = new int[n];
 
		for(int i = 0; i < n ; i++)
		{
			tab[i] = rand.nextInt(100);
		}	
	}

D'avance merci pour l'aide que vous pourrez m'apporter quand à ce problème. Le suivant sera pour moi de gérer des char entrés au clavier

[mroudy]

Bon, après un bon mal de crâne je pense avoir réussi à faire ce que je voulais.
Du coup je pose mon code final, si vous avez des remarques vis à vis de ce dernier merci de me le faire remarquer.

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
 
package Pile;
 
import java.util.Random;
 
public class PileTab {
 
    private int tailleMax; // Taille maximale
    private int sommet = -1; // Sommet du tableau
    private int[] tab;
 
    // Constructeur: crée une pile vide de taille maximale donnée
    public PileTab(int max) {
	tailleMax = max; // je ne sais pas si cette variable est obligatoire
	sommet = -1;
	tab = new int[tailleMax];
    }
 
    /** Teste si une pile est vide */
    public boolean EstVide() {
	return (sommet == -1);
    }
 
    /** Empiler */
    public void Empiler(int v) {
	if (sommet == tailleMax - 1) {
	    System.out.println("Impossible d'empiler: la pile est pleine");
 
	}
 
	sommet++;
	tab[sommet] = v;
    }
 
    /** Dépiler */
    public void Depiler() {
	if (EstVide()) {
	    System.out.println("la pile est vide");
	}
 
	sommet--;
    }
 
    // Affichage du tableau
    void Afficher() {
	System.out.print("[");
	for (int i = 0; i < tab.length; i++) {
	    System.out.print(tab[i]);
 
	    if (i < tab.length - 1)
		System.out.print("-");
	}
	System.out.println("]\n");
    }
 
    public void Init() {
	Random rand = new Random();
	for (int i = 0; i < tailleMax; i++) {
	    tab[i] = rand.nextInt(100);
 
	}
    }
 
    /** Retourne la valeur du sommet */
    public int sommet() {
	if (EstVide()) {
	    System.out.println("la pile est vide");
 
	}
 
	return tab[sommet];
    }
 
    public void Pairs() {
	// int [] nbpairs; while (sommet != tailleMax - 1) {
	for (int i = 0; i < tailleMax; i++) {
	    if (tab[i] % 2 == 0) {
		int[] nbpairs = new int[tailleMax];
		nbpairs[i] = tab[i];
		// tab[i] = nbpairs[i];
		System.out.print(nbpairs[i] + " ");
	    }
	}
	// return tailleMax;
 
    }
 
    public static void main(String[] args) {
	PileTab P1 = new PileTab(20);
	P1.Init();
	P1.Afficher();
	P1.Pairs();
 
    }
}

[dinobogan]

Ca va provoquer des ArrayIndexOutOfBoundsException.
Ta variable "tabMax" est inutile puisque tu peux utiliser ".length" sur ton tableau pour connaitre sa taille.
Ensuite, ta variable "sommet" doit être initialisée à 0.
Enfin, les méthodes d'accès ne sortent pas au bon moment sur une erreur.

Code :

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

1
2
3
4
5
6
7
void empiler( int v )
{
  if( ! isPlein() )
  {
    tabSommet[sommet++] = v;
  }
}

Code :

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

boolean isPlein() { return sommet == tabSommet.length; }

Code :

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

1
2
3
4
void depiler()
{
  if( ! isVide() ) { --sommet; }
}

Code :

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

boolean isVide() { return sommet == 0; }

Code :

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

1
2
3
4
5
int sommet()
{
  if( isVide() ) { throw new ArrayIndexOutOfBoundsException(); }
  return tabSommet[sommet];
}

Par contre, une pile est plus souvent utilisée avec les méthodes suivantes :

1. push : ajouter une valeur en haut de pile
2. pop : envoie la valeur en haut de la pile et décrémente la pile
3. size : envoie la taille de la pile
4. peek : obtenir la valeur en haut de pile sans la retirer de la pile

[mroudy]

Bon après pas mal de changements j'ai trouvé une solution qui fonctionne, il y a peut-être les char qui pourraient être remplaçés par des int je crois. Là non plus je n'en suis pas certain.

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
 
class Cellule
{
	char valeur;
	Cellule suivant;
 
	//Constructeur
	Cellule(char _valeur)
	{
		valeur = _valeur;
		suivant = null;
	}	
}
 
class PileListe
{
  Cellule Sommet;
 
  PileListe()
  {
    Sommet = null;
  }
 
  void Afficher()
  {
		Cellule c = Sommet;
 
		while(c != null)
		{
			System.out.print(c.valeur + " ");
			c = c.suivant;
		}
		System.out.println("|");
  }
 
  void Empiler(char val)
  {
    Cellule tmp = new Cellule(val);     
    //On affecte la liste courante en tant que queue
    tmp.suivant = Sommet;   
    //On Ecrase la liste courante par la nouvelle liste           
    Sommet = tmp;       
  }
 
  char Depiler()
  {  
    char val = Sommet.valeur;
 
    Sommet = Sommet.suivant;
 
    return val;    
  }
 
  boolean Est_vide()
  {
    if(Sommet == null)
      return true;
    else
      return false;    
  }
 
  void Inverser()
  {
    PileListe p = new PileListe();
 
    while(!Est_vide())
    {
      p.Empiler(Depiler());
    }
 
    Sommet = p.Sommet;        
  }
 
 
}

Si vous avez des remarques, je suis preneur.
En ce qui concerne les méthodes suivante, le but est de ne pas les utiliser. Aller savoir pourquoi mais c'est ce que l'on me demande. D'ailleurs, je bosse également sans utiliser les méthodes add, remove... juste une lubie de ma prof certainement pour mieux comprendre le déroulement du code. J'avoue ne pas vraiment comprendre pourquoi et du coup ce que je trouve sur le net ne m'aide pas vraiment.
push : ajouter une valeur en haut de pile
pop : envoie la valeur en haut de la pile et décrémente la pile
size : envoie la taille de la pile
peek : obtenir la valeur en haut de pile sans la retirer de la pile