Discussion :

[hellowo]

Bonsoir à tous !
Je débute sur les listes chainées et on nous demande dans un projet de créer un polynôme(sous forme développée) sous forme de liste chainée dont les maillons sont des monomes eux même représentés par leur coefficient et leur degré. Les coefficients doivent de plus être son forme complexe (1-i) par exemple. Etant donné que j'ai pas mal de lacunes (voir beaucoup ) , j'ai juste pu créer les types de strcture pour le monome et le polynome:

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
#include <stdio.h>
   #include <stdlib.h>
 
   typedef struct monom monom{
   struct monom
   {
   int degre;
   int coeff;
   };
  typedef monom monome;
 
  typedef struct element element{
  struct element
  {
  monome m;
  struct element *nxt;
  };
  typedef element *PolyDeveloppe;

Je ne sais pas vrament comment faire ensuite, peut etre créer une fonction pour préparer le monome et une autre pour afficher le polynome en appelant la fonction précédente ... Bref j'aimerai avoir des indices pour m'aider à avancer. En espérant une aide précieuse

[fearyourself]

Déjà. je pense que le début est que cela compile non? On dirait que ton code ne compilerait même pas. Ensuite, en effet, une fonction pour créer un monome, une fonction pour l'ajouter à un polynôme, une fonction pour afficher un polynôme, changer un coefficient, etc.

[Sve@r]

Code C :

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

1
2
3
4
5
6
7
8
9
   
   typedef struct monom monom{
   struct monom
   {
   int degre;
   int coeff;
   };
  typedef monom monome;
  typedef element *PolyDeveloppe;

Bonjour

En dehors des erreurs de syntaxe (accolade ouverte inutilement), partir avec des noms comme "monom", "monome" et surtout cacher une étoile derrière un type c'est le meilleur moyen d'aller au mur. Suffit d'un seul endroit où tu auras du &PolyDeveloppe (et ça arrivera fatalement dès que tu devras modifier ton premier élément) et tu ne sauras plus ce que tu manipules.

Commence par adopter le standard conventionnel. Les structures se nomment s_xxx et les types t_xxx. Ensuite pose de bonnes bases bien solides. Tu as parlé de coefficient complexe mais je n'ai rien vu qui y ressemble. Arrête de penser systématiquement "int" dès que tu as un élément numérique sans réfléchir plus profondément sur la valeur possible de cet élément. Et surtout surtout crée-toi un type dédié à la liste elle-même. J'explique ici pourquoi avec un exemple complet de liste chainée mais le premier avantage de ce type c'est que ça t'évitera d'avoir à cacher ton étoile...

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
typedef struct {
    int reel;
    int img;
} t_complex;
 
typedef struct {
    unsigned short degre;
    t_complex coeff;
} t_monome;
 
typedef struct s_noeud {
    t_monome monome;
    struct s_noeud* next;
} t_noeud;
 
typedef struct {
    t_noeud *first;
} t_liste;
 
void liste_init(t_liste *l)
{
    l->first=NULL;
}
 
int main()
{
    t_liste liste;
    liste_init(&liste);
}

Ensuite ben comme l'a dit fearyourself, de petites fonctions dédiées à un travail bien précis que tu pourras appeler quand il faut (va voir l'exemple dont je t'ai parlé)...

[hellowo]

Re,
J'ai essayé de m'inspirer de l'exemple que tu m'as montré pour commencer à créer des fonctions afin d'afficher le polynome mais c'est un échec total ...
En gros je sais qu'il y a des fonctions où je n'appelle pas le bon type et du coup forcément tout le code est faussé. De plus je ne pas comment gérer la structure avec les complexes. Néanmoins merci beaucoup de tes conseils sur le standart à adopter, je m'en servirai pour la suite.
Voici le code(beaucoup inspiré de ton exemple mais que je n'ai pas su exploiter):

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
#include <stdio.h>
#include <stdlib.h>
 
typedef struct {
    int reel;
        int img;
	} t_complex;
 
typedef struct {
	unsigned short degre;
	t_complex coeff;
}t_monome;
 
typedef struct s_noeud{
	t_monome monome;
	struct s_noeud* next;
}t_noeud;
 
typedef struct{
	t_noeud *first;
}t_liste;
 
void liste_init(t_liste *l)
{
	l->first = NULL;
}
 
t_noeud *noeud_ajout(unsigned short degre, int coeff)
{
	t_noeud *monome;
	//allocation mémoire
	if((monome = malloc(sizeof(t_noeud))) == NULL)
	{
		return NULL;
	}
	//remplissage
	monome->degre = degre;
	monome->coeff= coeff;
	return monome;
}
 
t_liste *liste_insere(t_liste *liste, t_noeud *monome)
{
t_noeud *courant;
	if(monome == NULL){
		return NULL;
	}
//Quand la liste est vide
if(liste->first == NULL)
{
	liste->first = monome;
	return liste;
}
//pour le premier élément
if(monome->degre > liste->first->degre) //Ici je cherche à placer un monome de degré supérieur à l'élément premier de la liste
{
	monome->suivant = liste->first;
	liste->first = monome;
	return liste;
}
//J'insère des monomes en remontant la liste tout en cherchant  à trier le polynome en placant les monomes de degré dans l'ordre décroissant
for (courant = liste->first; courant->next != NULL && courant->next->degre > monome->degre; courant = courant->next){
	monome->next = courant->next;
	courant->next = monome;
	return liste;
}
}
 
 
void liste_affiche(t_liste * liste)
{
	if (liste == NULL)
	{
		exit(EXIT_FAILURE);
	}
	t_noeud *courant = liste;
	printf("Polynome :");
	while(courant != NULL)
	{
		printf("%dx^%d + ",courant->coeff, courant->degre);
		courant = courant->next;
	}
	printf("\n");
}
 
int main()
{
	t_liste liste;
	liste_init(&liste);
liste_affiche(&liste);
//insertion de monome
liste_insere(&liste, noeud_ajout(1,2-i));
liste_insere(&liste, noeud_ajout(3,3-i));
liste_insere(&liste, noeud_ajout(4,1-i));
liste_insere(&liste, noeud_ajout(2,6-i));
liste_insere(&liste, noeud_ajout(0,3-i));
 
return 0;
}

Bien sur cela ne compile pas ...
Voilà peut etre que tout est à refaire mais il faudrai que je comprenne vraiment à quel type faire appel pour mes fonctions pour que cela marche.
Merci d'avance

[gerald3d]

Bonjour.

Tu devrais utiliser quelques options à la compilation pour que le compilateur t'aide un peu dans le déboggage de ton code. Voila une copie de la compilation de ton code chez moi :

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
main.c: In function ‘noeud_ajout’:
main.c:37:8: error: ‘t_noeud’ has no member named ‘degre’
  monome->degre = degre;
        ^
main.c:38:8: error: ‘t_noeud’ has no member named ‘coeff’
  monome->coeff= coeff;
        ^
main.c: In function ‘liste_insere’:
main.c:55:10: error: ‘t_noeud’ has no member named ‘degre’
 if(monome->degre > liste->first->degre) //Ici je cherche à placer un monome de degré supérie
          ^
main.c:55:32: error: ‘t_noeud’ has no member named ‘degre’
 if(monome->degre > liste->first->degre) //Ici je cherche à placer un monome de degré supérie
                                ^
main.c:57:8: error: ‘t_noeud’ has no member named ‘suivant’
  monome->suivant = liste->first;
        ^
main.c:62:68: error: ‘struct s_noeud’ has no member named ‘degre’
 for (courant = liste->first; courant->next != NULL && courant->next->degre > monome->degre; cou
                                                                    ^
main.c:62:84: error: ‘t_noeud’ has no member named ‘degre’
 for (courant = liste->first; courant->next != NULL && courant->next->degre > monome->degre; cou
                                                                                    ^
main.c: In function ‘liste_affiche’:
main.c:76:21: error: initialization from incompatible pointer type [-Werror]
  t_noeud *courant = liste;
                     ^
main.c:80:29: error: ‘t_noeud’ has no member named ‘coeff’
   printf("%dx^%d + ",courant->coeff, courant->degre);
                             ^
main.c:80:45: error: ‘t_noeud’ has no member named ‘degre’
   printf("%dx^%d + ",courant->coeff, courant->degre);
                                             ^
main.c: In function ‘main’:
main.c:92:38: error: ‘i’ undeclared (first use in this function)
 liste_insere(&liste, noeud_ajout(1,2-i));
                                      ^
main.c:92:38: note: each undeclared identifier is reported only once for each function it appears in
main.c: In function ‘liste_insere’:
main.c:67:1: error: control reaches end of non-void function [-Werror=return-type]
 }

Les options utilisées ici : -Wunused -Wall -Werror

Pour te donner une petite aide regarde comment tu as déclarer la structure d'un nœud :

Code :

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

1
2
3
4
typedef struct s_noeud{
	t_monome monome;
	struct s_noeud* next;
}t_noeud;

Première chose, il me semble que l'on t'a dit s_xxx pour les structures, t_xxx pour les types. Ici tu mélanges les écritures, pire, tu écris un code qui ne prends pas en compte le nom t_nœud (qui n'est donc pas opportun ici).
La remarque est aussi valable pour t_monome et t_complex...

[Sve@r]

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
#include <stdio.h>
 
typedef struct {
	unsigned short degre;
	t_complex coeff;
}t_monome;
 
typedef struct s_noeud{
	t_monome monome;
	struct s_noeud* next;
}t_noeud;
 
t_noeud *noeud_ajout(unsigned short degre, int coeff)
{
	t_noeud *monome;
	//allocation mémoire
	if((monome = malloc(sizeof(t_noeud))) == NULL)
	{
		return NULL;
	}
	//remplissage
	monome->degre = degre;
	monome->coeff= coeff;
	return monome;
}

monome est de type "t_noeud" (dans la famille "je me mélange tout" je voudrais le fils...). Et le paramètre reçu doit-être de type t_monome puisque c'est lui que tu veux stocker !!!

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
t_noeud *noeud_ajout(t_monome monome)
{
	t_noeud *noeud;
	//allocation mémoire
	if((noeud = malloc(sizeof(t_noeud))) == NULL)
	{
		return NULL;
	}
	//remplissage
	noeud->next=NULL;
	noeud->monome.degre=monome.degre;
	noeud->monome.coeff.reel=monome.coeff.reel;
	noeud->monome.coeff.img=monome.coeff.img;
	return noeud;
}

Faudrait aussi quand-même étudier les types que je t'ai proposés...

Bien sur cela ne compile pas

Réellement on se demande pourquoi...???

[gerald3d]

Dans la foulée un autre exemple de ton code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
s_noeud *noeud_ajout(unsigned short degre, int coeff)
{
  s_noeud *monome;
  //allocation mémoire
  if((monome = malloc(sizeof(s_noeud))) == NULL)
    {
      return NULL;
    }
  //remplissage
  monome->degre = degre;
  monome->coeff= coeff;
  return monome;
}

J'ai déjà pris la liberté de mon côté de remettre de l'ordre dans tes structures. Donc ta fonction alloues un s_noeud mais ensuite tu veux accéder aux éléments de s_monome ! Le compilateur hurle à la mort C'est le bordel chef !

[diogene]

J'ajoute mes commentaires :

Dans l'ensemble, ce n'est pas mal du tout et c'est très encourageant (il y a beaucoup de grincheux sur le forum mais ils ne sont pas méchants ). Un choix malheureux de certains identificateurs a conduit à des erreurs dans le code, mais il n'y a au final que peu d'erreurs ce qui ne demandent pas une refonte importante du code

1-

Code :

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

1
2
3
4
typedef struct {
    int reel;
        int img;
	} t_complex;

Les champs pris ici comme entiers ne devraient-ils pas être des réels ?

2- Dans noeud_ajout() :
-

Code :

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

1
2
3
4
	t_noeud *monome;
...
	monome->degre = degre;
	monome->coeff= coeff;

degre et coeff ne sont pas un champ de t_noeud. Tout vient d'une appellation fausse où un noeud a été appelé monome, d'où la confusion. Un bon choix des identificateurs est le plus utile des commentaires du code.
- Si les coefficients sont complexes, il faut passer deux valeurs, l'une pour la partie réelle et l'autre pour la partie imaginaire
- Le champ next n'a pas été initialisé à NULL. C'est risqué.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
t_noeud *noeud_ajout(unsigned short degre, int coeffr, int coeffi)
{
   t_noeud *noeud;
   //allocation mémoire
   if((noeud = malloc(sizeof(t_noeud))) == NULL) return NULL;
   //remplissage
   noeud->monome.degre = degre;
   noeud->monome.coeff.reel = coeffr;
   noeud->monome.coeff.img = coeffi;
   noeud->next = NULL;
   return noeud;
}

3- Dans liste_insere()
- Même remarque pour l'identificateur monome.
- L'insertion en milieu de liste est fausse

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
t_liste *liste_insere(t_liste *liste, t_noeud *noeud)
{
   t_noeud *courant;
   if(noeud == NULL) return NULL;
   // Quand la liste est vide
   if(liste->first == NULL)
   {
      liste->first = noeud;
      return liste;
   }
   // pour le premier élément
   if(noeud->monome.degre > liste->first->monome.degre)
   // Ici je cherche à placer un monome de degré supérieur à l'élément
   // premier de la liste
   {
      noeud->next = liste->first;
      liste->first = noeud;
      return liste;
   }
   // J'insère des monomes en remontant la liste tout en cherchant à trier
   // le polynome en placant les monomes de degré dans l'ordre décroissant
   for (courant = liste->first; courant->next != NULL && courant->next->monome.degre > noeud->monome.degre; courant = courant->next)
   {  // le bloc est vide
   }
   noeud->next = courant->next;
   courant->next = noeud;
   return liste;
}

4- liste_affiche()
- l'initialisation de courant est fausse
- L'affichage sera à peaufiner plus tard

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void liste_affiche(t_liste * liste)
{
   t_noeud *courant = liste->first;
   if (liste == NULL)exit(EXIT_FAILURE);
   printf("Polynome :");
   while(courant != NULL)
   {
      printf("(%d+%di)x^%d + ",courant->monome.coeff.reel,courant->monome.coeff.img,
                               courant->monome.degre);
      courant = courant->next;
   }
   printf("\n");
}

5- le main() modifié en conséquence

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int main(void)
{
   t_liste liste;
   liste_init(&liste);
   liste_affiche(&liste);
//insertion de monome
   liste_insere(&liste, noeud_ajout(1,2,1));
   liste_insere(&liste, noeud_ajout(3,3,2));
   liste_insere(&liste, noeud_ajout(4,1,3));
   liste_insere(&liste, noeud_ajout(2,6,4));
   liste_insere(&liste, noeud_ajout(0,3,5));
   liste_affiche(&liste);
   return 0;
}