Discussion :

[ghyosmik]

Bonjour,

Je débute en c++ et j'ai besoin d'un coud de main afin de résoudre cet exercice,

/*
L'objectif est de travailler avec une liste chaînée d'entiers positifs ou nuls.
En un premier temps, le programme invoque la fonction saisir qui saisit
les données à partir du clavier. Au fur et à mesure de l'insertion, les données
sont insérées dans une liste chaînée de telle sorte que les données soient croissantes
dans cette liste; on utilise pour cela la fonction inserer, qui utilise elle-même
la fonction nouveau_maillon;.
On affiche le contenu de la liste chaînée pour vérifier le résultat avec
la fonction ecrire_liste.
Ensuite, on renverse la liste chainée avec la fonction inverser : les données deviennent
classées par ordre décroissant. Une contrainte est imposée à la fonction inverser :
n'utiliser aucune création de struct maillon, c'est-à-dire aucun malloc.
On vérifie le résultat avec la fonction ecrire_liste.
Enfin, on libère l'espace-mémoire alloué à la liste chainée avec la fonction liberer.
*/


merci d'avance pour votre aide

[Goten]

Ici on ne donne pas de codes tout fait.. Tu bloques quelques part? (j'entends, à tu déjà fait un bout de code)?

[ghyosmik]

J'ai essayé avec celui-ci mais j'arrive pas à le debugger et j'ai l'impression que ca marche pas!!

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
#include <stdio.h>
#include <stdlib.h>
 
struct maillon
{
 int valeur;
 struct maillon * suivant;
};
 
typedef struct maillon * VersMaillon ;
 
VersMaillon construire(void);
void ecrire(VersMaillon);
VersMaillon renverser(VersMaillon);
 
void main()
{
 VersMaillon debut;
 
 debut=construire();
 printf("Voici la liste de vos entiers dans l'ordre de la liste chaînée construite : \n");
 ecrire(debut);
 debut=renverser(debut);
 printf("Voici la liste de vos entiers dans l'ordre de la liste chaînée renversée : \n");
 ecrire(debut);
}
 
VersMaillon construire()
{
 VersMaillon deb, p;
 int donnee;
 
 
 deb=NULL;
 printf("Donnez vos données, tapez -1 pour terminer : \n");
 scanf("%d",&donnee);
 while (donnee!=-1)
   {
     p=(VersMaillon) malloc(sizeof(struct maillon));
     p->valeur=donnee;
     p->suivant=deb;
     deb=p;
     scanf("%d",&donnee);
   }
 return deb;
}
 
VersMaillon renverser(VersMaillon deb)
{
 VersMaillon p, q ,r;
 
 if ((deb==NULL)||(deb->suivant==NULL)) return deb;
 q=deb->suivant;
 deb->suivant=NULL;
 r=q->suivant;
 q->suivant=deb;
 while (r!=NULL)
   {
     p=q;
     q=r;
     r=r->suivant;
     q->suivant=p;
   }
 deb=q;
 return deb;
}
 
void ecrire(VersMaillon deb)
{
 VersMaillon p;
 
 p=deb;
 
 while (p!=NULL)
   {
     printf("%d ",p->valeur);
     p=p->suivant;
   }
 printf("\n");
}

[Goten]

Hum... ton code là écrit comme ça c'est du C.

Pour la chaine en C++ on utiliserai deux class:

une class maillon
et une class liste qui gèrerai les maillons.

[ghyosmik]

ah ok!

je suis entrain de faire un autre code! mais en execution ca n'aboutit pas à la bonne résultat!!!

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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
#include <stdio.h>
#include <stdlib.h>
 
struct maillon
{
 int donnee;
 struct maillon * suivant;
};
 
typedef struct maillon Maillon;
 
/* Les prototypes des fonctions */
Maillon * nouveau_maillon(int, struct maillon *);
Maillon * inserer(Maillon * , int);
Maillon * saisir(void);
void ecrire_liste(Maillon *);
Maillon * inverser(Maillon *);
void liberer(Maillon *);
 
 
int main(int argc, char ** argv)
{
 Maillon * debut;
 
 debut = saisir();
 printf("liste croissante \n");
 ecrire_liste(debut);
 
 debut = inverser(debut);
 printf("liste decroissante \n");
 ecrire_liste(debut);
 
 liberer(debut);
 return 0;
}
 
/*
 Crée un nouveau maillon en mettant la valeur cle dans le champ donnee et
 la valeur deb dans le second champ.
.*/
Maillon * nouveau_maillon(int cle, struct maillon * deb)
{
 
 Maillon * nouveau = (Maillon *) malloc(sizeof(Maillon));
 nouveau -> donnee = cle;
 nouveau -> suivant = deb;
 return nouveau;
}
 
 
/*
  Insère la valeur cle dans la liste triée par valeurs croissantes
  de début "debut" en respectant l'ordre.
  On insère la nouvelle valeur même si elle figurait déjà.
  Renvoie le début de la liste après insertion.
 
  On distingue d'abord le cas où la liste serait vide et le cas où cle serait
  inférieure à la première donnée de la liste.
  On cherche ensuite la place de cle en utilisant deux pointeurs p et q et en
  faisant en sorte que, au moment de l'insertion, p et q pointent sur deux maillons
  consécutifs, le premier maillon contenant une donnée < cle et le suivant une donnée > cle.
*/
Maillon * inserer(Maillon * debut, int cle)
{
 Maillon * p, * q;
 
 if ((debut == NULL) || (cle < debut -> donnee))
    debut = nouveau_maillon(cle, debut);
 else
   {
     p = debut;
     q = p -> suivant;
     while ((q != NULL) && (cle > q -> donnee))
       {
         p = q;
         q = q -> suivant;
       }
     p -> suivant = nouveau_maillon(cle, q);
   }
 return debut;
}
 
/*
 Demande à l'utilisateur les données et les insère au fur et à mesure
 dans la liste chaînée, de telle sorte que la liste soit triée.
 Utilise la fonction inserer.
 L'utilisateur indique la valeur -1 pour indiquer qu'il n'y a plus de données
*/
Maillon * saisir()
{
 
 Maillon * debut = NULL;
 int cle;
 
 printf("vos données, indiquez la fin avec la valeur -1 ? \n");
 scanf("%d", &cle);
 while (cle != -1)
   {
     debut = inserer(debut, cle);
     scanf("%d", &cle);
   }
 return debut;
}
 
 
/*
 Ecrit sur la sortie standard les données de la liste  chainée
 de début "debut" .
*/
void ecrire_liste(Maillon * debut)
{
 Maillon * p = debut;
 
 while (p != NULL)
   {
     printf("%d ", p -> donnee);
     p = p-> suivant;
   }
 printf("\n");
}
 
/*
 Prend un à un les maillons de la liste chainée de début "debut" pour
 construire une nouvelle liste chaînée qui est dans l'ordre inverse.
 Renvoie le début de la liste après inversion.
 La liste doit être inversée sans faire d'allocation dynamique (aucun malloc).
*/
Maillon * inverser(Maillon * debut)
{
 Maillon * debut_inverse = NULL, * p;
 
 while (debut != NULL)
   {
     p = debut;
     debut = debut -> suivant;
     p -> suivant = debut_inverse;
     debut_inverse = p;
   }
 return debut_inverse;
}
 
/*
 Libère la liste chaînée.
*/
void liberer(Maillon * debut)
{
 Maillon * p = debut;
 while (debut != NULL)
   {
     debut = debut -> suivant;
     free(p);
   }
}

[Goten]

T'es sur de pas t'être trompé de section ? Parce que là si tu veux coder en C++ tu peux oublier tout les include de la librairie standart en .h
tout comme les printf et autres scanf