problème dans une séparation d'une pile

Version imprimable

Bonsoirs tous le monde ,je veux séparer une pile contiguë en deux parties parties une partie pour les éléments positives ou nuls et une autre partie des éléments négatives mais le problème de mon programme ne le fais pas même si j'ai fais une procédure pour séparer mais sa ne marche pas de plus se que je veux savoir si mon problème et dans le main ou la procédure separation ?donc s'il vous plais il me faut de l'aide .merci d'avance:)

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
 
#include<stdio.h>
 
typedef struct{
	int T[100];
	int sommet;
}pile;
 
void inisialiserP (pile *p)
{
	p->sommet=-1;
}
 
void empiler(pile *p,int e)
{
	if(p->sommet==99)
	{
	printf("la pile est pleine");
	}
	else
	{
		p->sommet++; 	
	     p->T[p->sommet]=e;	 
	}
 
}
 
void depiler(pile *p)
{
	if(p->sommet!=-1)
	{
		p->sommet--;
	}
	else
	{
		printf("La pile est vide !");
	}
}
 
int  pile_pleine(pile *p )
{
	if(p->sommet=p->sommet-1) return 1;
	else return 0;
 
}
 
int pile_vide(pile *p)
{
	if(p->sommet==-1) return 1;
	else return 0;
}
 
void separation(pile *p, pile *p1, pile *p2)
{
	 int i;
    inisialiserP(p1);
    inisialiserP(p2);
 
        for(i=0 ;i<p->sommet ;i++)
		{
        if(p->T[p->sommet]>=0) empiler(p1,p->T[p->sommet]) ;
        else empiler(p2,p->T[p->sommet]);
        depiler(p);
        }
}
 
main()
{
	pile p,p1,p2;
	int i,n,e;
 
	inisialiserP(&p1);
    inisialiserP(&p2);
 
    inisialiserP(&p);   
	printf("Donner le nombre des elements a inserer dans la pile: ");
	scanf("%d",&n);
 
	for(i=0;i<n;i++)
	{
		printf("t[%d]=",i);
		scanf("%d",&e);
		empiler(&p,e);
	}
 
	printf("---La pile apres inserssion---\n");
	for(i=0;i<n;i++)
	{
		printf("p.T[%d]=%d\n",i,p.T[i]);
	}
 
    separation(&p,&p1,&p2);
    printf("---Separation---:\n");
    printf("la pile p1 qui contient les elements positifs ou nuls de p:\n");
    for(i=0;i<p1.sommet;i++)
	{
        printf("p1.T[%d]=%d \n ",i,p1.T[i]);
    }
    printf("la pile p2 qui contient les elements negative de p:\n");
    for(i=0;i<p2.sommet;i++)
	{
        printf("p2.T[%d]=%d \n ",i,p2.T[i]);
    }
}

Bonjour.

Sans vraiment répondre à ta question il me semble que ton code pourrait être plus "élégant".

Tu vérifies dans empiler(); si la pile est pleine. Tu fais de même dans depiler(); en vérifiant si la pile est vide. Hors tu as créé deux fonctions qui font déjà le travail. Il suffirait d'ajouter dans pile_pleine (); le printf(); ainsi que dans pile_vide (); comme ceci :
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 int pile_pleine(pile *p ) { if (!p) { fprintf (stderr, "p vaut null dans pile_pleine();\n"); return 1; } if(p->sommet=p->sommet-1) { printf("la pile est pleine"); return 1; } return 0; } int pile_vide(pile *p) { if (!p) { fprintf (stderr, "p vaut null dans pile_vide();\n"); return 1; } if(p->sommet==-1) { printf("La pile est vide !"); return 1; } return 0; }
Au passage tu remarqueras que j'ai aussi supprimé le else qui ne sert à rien ici. En effet si la condition est vraie on sort de la fonction. Donc dans l'autre cas on retourne forcément 0. Ceci à aussi l'avantage d'éviter un warning à la compilation selon les options choisies.

Autre remarque. Le code en rouge dans les deux fonctions permettent de rendre ton code plus robuste. Tu vérifies si le paramètre transmis à la fonction est "correcte". Ici on vérifie simplement si le pointeur n'est pas NULL. On pourrait vérifier aussi si le pointeur transmis est du bon type mais l'idée ici est de te montrer ce qu'il faut faire lorsqu'on crée une fonction. Ainsi, si tu transmets un pointeur NULL tu auras un message en console et tu pourras déboguer plus facilement.

Mais revenons à nos moutons, maintenant que tes fonctions pile_vide(); et pile_pleine(); font tout le travail, il suffit de modifier empiler(); et depiler(); de cette façon :
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 void empiler(pile *p,int e) { if(p->sommet==99) { printf("la pile est pleine"); } else { if (pile_pleine (p)) return; p->sommet++; p->T[p->sommet]=e; } } void depiler(pile *p) { if (pile_vide (p)) return; if(p->sommet!=-1) { p->sommet--; } else { printf("La pile est vide !"); } }
Remarque : tu pourrais comme pour les fonctions précédentes vérifier si p est valide dans empiler(); et depiler(); et appliquer cette technique à toutes tes fonctions. Tu arriverais j'en suis sûr à trouver les solutions aux problèmes qui t'amènent ici.

Qu'en penses-tu ?

Je continue sur ma lancée :).

Dans le main () tu initialises p1 et p2. À priori ce n'est pas une mauvaise idée.

Cependant tu ne les utilises qu'à partir du moment ou tu lances separation();. Hors dans cette fonction tu initialises à nouveau p1 et p2 ! Un coup de trop à mon avis.

Ici tu pourrais faire autrement. Puisque separation(); doit remplir p1 et p2 tu pourrais simplement supprimer ces initialisations redondantes. En partant de là tu pourrais encore une fois vérifier si tous les pointeurs que tu transmets sont biens initialisés :
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 void separation(pile *p, pile *p1, pile *p2) { int i; inisialiserP(p1); inisialiserP(p2); if (!p) { fprintf (stderr, "p vaut null dans separation();\n"); return; } if (!p1) { fprintf (stderr, "p1 vaut null dans separation();\n"); return; } if (!p2) { fprintf (stderr, "p2 vaut null dans separation();\n"); return; } for(i=0 ;i<p->sommet ;i++) { if(p->T[p->sommet]>=0) empiler(p1,p->T[p->sommet]) ; else empiler(p2,p->T[p->sommet]); depiler(p); } }

04/11/2018, 20h10
fashi

Merci beaucoup pour votre aide :)