Discussion :

[nadjibmp]

Bonsoir à tout le monde,
j'essaie de trier une pile d'entiers mais ça n'a pas marché.
voici mon code :

Code C :

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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#include <stdio.h>
#include <stdlib.h>
typedef
struct
{
    int tab[5];
    int s;
}Pile_s;
void empiler (Pile_s *P,int x )
 
{
    if(est_pleine(*P))
    {
    (*P).tab[(*P).s]=x ;
    (*P).s=(*P).s+1 ;
    }
 
 
 
 
}
void depiler (Pile_s *P , int x )
{
    x=(*P).tab[(*P).s];
    (*P).s=(*P).s-1 ;
}
int est_pleine(Pile_s P)
{
    if (P.s=6)
        return 1;
        else return 0;
}
int est_vide(Pile_s P)
{
    if (P.s==0)
    return 0 ;
}
void affichage(Pile_s P)
{int i=0 ;
    if (est_vide(P))
    {
        printf("votre pile est vide \n");
 
    }
    else
        printf("[");
    {
        while (i<P.s){
 
            printf("%d  ",(P).tab[i]);
 i++;
 
        }
    }printf("] ");
 
 
}
int nbr_element(Pile_s p)
{
    return p.s++ ;
}
void tri (Pile_s *p)
{Pile_s *q,*s ;
int *y , *x ,*temp ;
while (!est_vide(*p))
{
    depiler(&p,&x);
    y=x ;
    while (!est_vide(*p))
    {depiler(&p,&x);
    if (x<y)
    {
        temp=x ;
        x=y ;
        y=temp ;
        empiler(&q,x);
    }
    else
        if (x>y)
    {
        emplier(&q,x);
    }
 
 
    }empiler(&s,x);
}
while (!est_vide(*q))
{
    depiler (&q,&temp);
    empiler(&p,temp) ;
 
}
while (!est_vide(*s))
 
{
    depiler(&s,&temp);
    empiler(&p,temp);
}}
 
int main()
{
    Pile_s P ;
    (P).s =0;
    empiler(&P,10);
    empiler (&P,9);
    empiler (&P,11);
    empiler(&P,40);
     affichage(P);
    tri(&P);
 
 
    affichage(P);
    int a ;
    a=nbr_element(P);
    printf("\nle nombre des element est %d ",a);
    printf("\nHello world!\n");
    return 0;
}

[Médinoc]

Il y a des erreurs flagrantes dans tes fonctions de base:

1. est-vide() à laquelle il manque une ligne
2. nbr_element() qui modifie sa pile (heureusement prise par valeur, donc la vraie n'est pas modifiée)
3. est_pleine() qui modifie sa pile (heureusement prise par valeur, donc la vraie n'est pas modifiée) et retourne systématiquement 1
4. depiler() qui ne marche pas parce que x est pris par valeur, et en plus lit la mauvaise valeur (il faudrait baisser l'index avant de lire la valeur)

De plus, pourquoi utilises-tu la syntaxe (*P).tab au lieu du plus simple, plus lisible, P->tab?
Et aussi, ton compilo est visiblement mal configuré, ou bien il t'aurait signalé le problème de est_vide() et les incohérences dans les appels à depiler().

[nadjibmp]

voici le nouveau code

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
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
#include <stdio.h>
#include <stdlib.h>
#define size 10
 
typedef struct
{
	int tab[size];
	int s;
}Pile_s;
 
void empiler (Pile_s *P,int x )
{
	if(!est_pleine(*P))
	{
		P->tab[P->s]=x ;
		P->s++;
	}
	else printf("la pile est pleinne \n");
}
 
void depiler (Pile_s *P,int *x ){
 if (!est_vide(*P))
{
	(*x)=P->tab[P->s];
	P->s-- ;
}
else
    printf("\n la pile est vide \n");}
 
int est_pleine(Pile_s P)
{
	if (P.s >= size)
		return 1;
	else return 0;
}
 
int est_vide(Pile_s P)
{
if (P.s==0)
	return 0 ;
	else return 1 ;
}
 
void affichage(Pile_s P)
{
if (est_vide(P))
{
    int i=0 ;
    printf("[");
    while (i<P.s-1)
    {
        printf(" %d ",P.tab[i]) ;
        i++ ;
    }
printf(" %d ",P.tab[i]) ;
printf("]");
 
 
}}
int nbr_element(Pile_s p)
{
	return p.s++ ;
}
 
void tri (Pile_s *p)
{
	Pile_s *q,*s ;
	int *y , *x ,*temp ;
	while (!est_vide(*p))
	{
		    depiler(p,x);
            y=x ;
            while (!est_vide(*p))
		       {
		    	depiler(p,x);
			    if (x<y)
			       {
			     	temp=x ;
			    	x=y ;
			    	y=temp ;
				    empiler(q,*x);
			       }
			   else if (x>y)
			        {
				      empiler(q,*x);
			        }
		       }
    empiler(s,*x);
     while (!est_vide(*q))
      {
      depiler (q,temp);
      empiler(p,*temp) ;
	  }
	}
 
	while (est_vide(*s))
	{
		depiler(s,temp);
		empiler(p,*temp);
	}
}
 
int main()
{
	Pile_s P ;
	(P).s =0;
	empiler(&P,10);
	empiler (&P,9);
	empiler (&P,11);
	empiler(&P,40);
 
	affichage(P);
	printf("\n");
    tri(&P);
 
    affichage(P);
 
 
 
	int a ;
	a=nbr_element(P);
	printf("\nle nombre des element est %d ",a);
	printf("\nHello world!\n");
	return 0;
}

[dalfab]

Bonjour,

fonction empiler, utilise un passage par pointeur okay.
fonction dépiler, n'extrait pas le dernier mais le 'plus' que dernier!
fonction est_pleine, utilise un passage par valeur donc nécessite de copier la pile, fonctionne mais!
fonction est_vide, utilise un passage par valeur donc nécessite de copier la pile, fonctionne mais!
fonction affichage, affiche quelque chose si la pile est vide, si elle est non vide serait certainement mieux. Par contre le code précédent était okay.
fonction nbr_element, modifie sa pile (heureusement prise par valeur, donc la vraie n'est pas modifiée)!
fonction tri, plusieurs erreurs dont : le pointeur q n'est pas initialisé!

[nadjibmp]

svp corrigez cette procedure (pile dynamique)

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
void trie(pile *P)
{
      pile *q , *s ;
      int *x ,*y , *temp ;
       s=initialise();
       q=initialise();
 
        while (!est_vide(P))
       {depiler (P,x);
           y=x ;
              while(!est_vide(P))
               {depiler(P,x );
                 if (x<y)
                 {
                     temp = x ;
                     x=y ;
                     y=temp;
                     empiler (q,x);
                 }
                 else
                    if (x>y)
                 {
                     empiler(P,x);
                 }
             } empiler(s,x);
            while (!est_vide(q))
            {
            depiler (q,temp );
            empiler (P,temp);
                            }
       }
       while (!est_vide(s))
       {
           depiler (s,temp);
           empiler(P,temp);
       }}

[ternel]

Non.

Nous ne corrigeons pas le code, nous aidons à comprendre pourquoi il est faux.

Donc, en quoi est-il faux?