tableau de listes

Version imprimable

tableau de listes

Voici mon code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 typedef int sommet; /*indice des sommets*/ typedef struct chainon { sommet st; // indice du sommet(de 0 à nmax-1) struct chainon *suivant; int nb_jetons; char type; } Couple; typedef Couple *liste; typedef struct { liste a[nmax]; //tableau de liste int n; }reseau; reseau rl;
Je souhaite remplir mon tableau de listes à l'aide d'un tableau rempli préalablement comme ceci mais ça ne marche pas, j'ai une erreur de segmentation qui doit provenir de ce que j'ai dans la boucle.Si quelqu'un pouvait m'aider, merci d'avance.
Code:

1 2 3 4 5 6 for(i=0;i<p;j++) { rl.a[i]->st=P[i]; // P étant le tableau rempli préalablement. rl.a[i]->type='p'; } }

22/11/2009, 19h06
Jerome Briot

Code:

for(i=0;i<p;j++)

C'est normal le j++ ?
22/11/2009, 19h12
guipe

Erreur de frappe. Sur mon programme c'est écrit correctement et ça ne marche quand même pâs !

Avec ausso peu de code, ca va etre difficile de t'aider.
On peut seulement dire les conseil habituel :
Code:

1 2 3 4 5 6 for(i=0;i<p;j++) { rl.a[i]->st=P[i]; // P étant le tableau rempli préalablement. rl.a[i]->type='p'; }
Verifie que tu as allouer a[i] (absent ici)
Code:

1 2 3 4 5 6 7 8 9 10 11 for(i=0;i<p;j++) { if (rl.a[i] != NULL) { rl.a[i]->st=P[i]; // P étant le tableau rempli préalablement. rl.a[i]->type='p'; } else fprintf(stderr, "ERREUR !! rl.a[%d] non alloue correctement.\n", i); }
Ensuite verifie que 'p' est bien le nombre de case de "rl.a".
Regarde si P[i] est valide.

Voila, si tout est valide, c'est que ca vient d'autre part et il nous faudra un code plus consequent.

22/11/2009, 20h37
guipe

Je dois allouer un espace mémoire pour mon tableau de liste a[i]? Mon but est de créer le tableau de listes a[i].Donc dans ma boucle je veux initialiser a[0]=P[0];a[1]=P[1]... Puis je veux voir les successeurs de a[0],a[1]...(qui se trouvent dans un fichier) et donc lister ces successeurs. Je nsais pas trop la forme du prog que je dois utiliser.
22/11/2009, 20h53
SofEvans

Et bien, vu que tu fais

Code:

typedef Couple *liste;

J'ai penser que

Code:

liste a[nmax]; //tableau de liste

Allouer un table unidimentionnel de pointeur vers Couple.
Donc, si ton tableau contient des "Couple*", alors il faut faire un malloc a chaque fois, sinon SegFault.
22/11/2009, 21h01
guipe
Ca ne suffit pas de faire ça?
Code:

1 2 3 4 5 6 7 8 typedef struct { liste a[nmax]; //tableau de liste int n; }reseau; reseau rl;
Comment je dois faire mon malloc et ou? Dans la boucle ?
22/11/2009, 21h06
SofEvans
Le probleme provient du fait que je ne suis pas sûr du type de liste.

si liste equivaut a "Couple", alors pas de malloc et il faut utiliser rl.a[i].st=P[i]; et non rl.a[i]->st=P[i];

si liste equivaut a "Couple*", alors il faut utiliser malloc dans la boucle.
Citation:
Ca ne suffit pas de faire ça?

Code :

Code:

1 2 3 4 5 6 7 8 typedef struct { liste a[nmax]; //tableau de liste int n; }reseau; reseau rl;

Comment je dois faire mon malloc et ou? Dans la boucle ?
Non, si liste == Couple*, ca suffit pas.
Tu peux faire le malloc dans la boucle.
Code:

1 2 3 4 5 6 7 for(i=0;i<p;j++) { /* Malloc ici */ rl.a[i]->st=P[i]; // P étant le tableau rempli préalablement. rl.a[i]->type='p'; }
22/11/2009, 21h30
guipe

Code:

a[i]= malloc(sizeof(?));
22/11/2009, 21h46
SofEvans

Si

liste == Couple*

alors

a[i]= (Couple*) malloc(sizeof(Couple));

Le cast du retour n'est pas obligatoire selon certaine personne
22/11/2009, 22h44
Pouet_forever

Citation:

Envoyé par SofEvans

Le cast du retour n'est pas obligatoire selon certaine personne

Non, et j'ai eu l'explication du pourquoi :ccool:
C'est parce qu'en fait au début dans la première «sortie» du C (ANSI je crois) le prototype du malloc était : char *malloc(int size) (pour le int je suis pas sûr)
Il n'y avais pas de pointeur générique (void*) et du coup le cast était obligatoire !
Après il ya a eu «une mise à jour» (ISO je crois) qui a introduit le pointeur générique (void*) et le cast du malloc est devenu facultatif.

Contenu du fichier dont je me sers pour créer mon tableau de listes :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
1 2 3 7 8 9
4 5 6 10 11
1:4
2:4 6
3:6
4:7
5:2
6:9
7:10
8:5
9:11
10:1 8
11:3 8

Voici mon code complet.
Explications: J'ai un fichier dans lequel sont contenus des caractères(voir au dessus).
Dans un premier temps je remplis 1 tableau P correspondant aux caractères de la 1ere ligne. Puis un tableau T correspondant aux caractères de la 2eme ligne.
Puis ce que je veux faire ensuite c'est créer un tableau de liste a[nmax]. Dans a[0],a[1],a[2].. je veux insérer le premier caractère de chaque ligne de mon fichier à partir de la 3ème ligne jusqu'à la dernière du fichier(a[0]=1,a[1]=2,a[2]=3...).Puis après je veux faire une liste chainée des caractères que je trouve après chaque":" de chaque ligne. Je veux chainer le premier caractère de la ligne(contenu dans mon tableau a[nmax] avec le ou les caractères qui suivent le ":" (ex: a[0]=1 chainé avec 4, a[1]=2 chainé avec 4 et 6...)Je pense que je suis un peu maladroit et que je ne m'y prends pas comme il faut.

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
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
154
155
156
157
158
159
160
161
162
//
//  Projet
//
 
#include <stdio.h>
#include <stdlib.h>
#define nmax 200 //definit le nombre max de sommet
typedef int sommet; /*indice des sommets*/
 
 
typedef struct chainon {
 
 	sommet st; // indice du sommet(de 0 à nmax-1)
 	struct chainon *suivant;
 	int nb_jetons;
	char type;
 } Couple;
 
typedef Couple liste;
Couple *ptrcouple;
 
typedef struct {
 
	liste a[nmax]; //tableau de liste
	int n;
 
} reseau;
 
 reseau rl;
 
 
int main()
{
 
	char c[4];
	char tmp;
	liste q,tmp2,tmp3,tmp4;
	int P[6];
	int T[20];
	int H[200];
	int i=0,p=0,t=0,h=0,j=0;
 
 
	FILE*fp;
	fp=fopen("reseau.txt","r");
 
 
	/****************************** PLACES *******************************/
	do
	{
		tmp=fgetc(fp);
		if(tmp==' ' || tmp=='\n') 
		{
			c[i]='\0';
			P[p]=atoi(c);
			i=0;
			p++;
		}
		else
		{
		c[i]= tmp;
		i++;
		}
 
	}while(tmp != '\n');
 
	/****************************** TRANSITIONS *******************************/
	do
	{
		tmp=fgetc(fp);
		if(tmp==' ' || tmp=='\n') 
		{
			c[i]='\0';
			T[t]=atoi(c);
			i=0;
			t++;
		}
		else
		{
			c[i]= tmp;
			i++;
		}
 
	}while(tmp != '\n');
 
	printf("Sommets\n");
	printf("places : " );
 
	for(i=0;i<p;i++)
	{
		printf("%d ",P[i]);
	}
	printf("\n");
	printf("transitions : ");
 
	for(i=0;i<t;i++)
	{
		printf("%d ",T[i]);
	}
	printf("\n");
 
	for(i=0;i<p;i++)
	{
		rl.a[i].st=P[i];
		rl.a[i].type='p';
	}
	printf("\n");
	i=p;
	while((i<(t+p))&&(j<t))
	{
			rl.a[i].st=T[j];
			rl.a[i].type='t';
            i++;
			j++;
	}
	for(i=0;i<(t+p);i++)
	{
		printf("%d ",rl.a[i].st);
	}
 
	for(i=0;i<(t+p);i++)
	{
		do
		{
			do
			{
				tmp=fgetc(fp);
				if(tmp==rl.a[i].st)
				{
					ptrcouple=malloc(sizeof(Couple));
					ptrcouple->st=tmp;
					rl.a[i]->suivant=ptrcouple;
					ptrcouple=&(rl.a[i]);
				}
			}while(tmp!=':');
 
			/*tmp=0;
			do
			{
				tmp=fgetc(fp);
				if(tmp==' ' || tmp=='\n') 
				{
					c[i]='\0';
					H[h]=atoi(c);
					tmp3=malloc(sizeof(Couple));
					tmp3.st=H[h];
					rl.a[i]->suivant=tmp3;
					tmp3=rl.a[i];
					i=0;
					h++;
					}
					else
						{
						c[i]= tmp;
						i++;
						}
			}while(tmp!='\n');
		*/	
		}while(tmp != EOF);
	} 
return(0);
}

23/11/2009, 13h58
guipe

Je veux chainer a[0] avec 4 puis a[1] avec 4 et 6 ... Je pense que vous pouvez m'aider.

a[0](1)->4

a[1](2)->4->6

a[2](3)->6

a[3](4)->7

a[4](5)->2

a[5](6)->9

a[6](7)->10

a[7](8)->5

a[7](9)->11

a[7](10)->1->8

a[7](11)->3->8
25/11/2009, 17h51
Bbaboulinet

Salut,
utilise plutot la fonction fread() ça éviterai dans ton cas de faire toutes tes boucles while.
Et mettre des noms de variable qui ont du sens aussi, parceque le mono-lettre ce n'est pas facile à lire.

Suite a conversation MSN, voici le code resolvant le probleme.
Il est assez crade au niveau de l'insertion dans les liste chainé.

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
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
154
155
156
157
158
159
160
161
 
#include <stdlib.h>
#include <stdio.h>
 
 
typedef struct Chainon Chainon;
struct Chainon
{
 	int indiceSommet;
 	Chainon *suivant;
 	int nombreJetons;
	char type;
};
 
 
 
typedef struct Reseau Reseau;
struct Reseau
{
	int *Place;
	int nombrePlace;
 
	int *Transition;
	int nombreTransition;
 
	Chainon* *Arcs;
	int nombreArcs;
};
 
 
int main(void)
{
    Reseau Pietri;
 
    /* Initialisation de la structure Pietri */
	Pietri.Place = NULL;
	Pietri.nombrePlace = 0;
	Pietri.Transition = NULL;
	Pietri.nombreTransition = 0;
	Pietri.Arcs = NULL;
	Pietri.nombreArcs = 0;
 
 
 
	FILE* fichier = fopen("reseau.txt","r");
	if (fichier == NULL)
	{
        perror("Erreur lors du chargement du fichier \"reseau.txt\" ");
        return EXIT_FAILURE;
    }
 
 
	/********************************* PLACES *********************************/
    int nombre;
    while (fscanf(fichier, "%d ", &nombre) == 1)
    {
        int *Temporaire = (int*) realloc (Pietri.Place, sizeof(int)*(Pietri.nombrePlace+1));
        if (Temporaire == NULL)
        {
            perror ("realloc a echoue lors de la lecture de la ligne \"Place\" ");
            /* Faire une action, a toi de voir (Quitter, continuer ?) */
        }
        else
        {
            /* On recupere l'ancien tableau avec une case en plus */
            Pietri.Place = Temporaire;
            /* On insere la nouvelle valeur */
            Pietri.Place[Pietri.nombrePlace] = nombre;
            /* et on n'oublie pas ... ^^ */
            Pietri.nombrePlace++;
        }
 
    }
 
 
 
	/****************************** TRANSITIONS *******************************/
	/* On s'est arreter a '*' avant, on va donc avancer d'un caractere */
	fseek(fichier,1,SEEK_CUR);
    while (fscanf(fichier, "%d ", &nombre) == 1)
    {
        int *Temporaire = (int*) realloc (Pietri.Transition, sizeof(int)*(Pietri.nombreTransition+1));
        if (Temporaire == NULL)
        {
            perror ("realloc a echoue lors de la lecture de la ligne \"Place\" ");
            /* Faire une action, a toi de voir (Quitter, continuer ?) */
        }
        else
        {
            Pietri.Transition = Temporaire;
            Pietri.Transition[Pietri.nombreTransition] = nombre;
            Pietri.nombreTransition++;
        }
 
    }
 
 
    /********************************** ARCS* *********************************/
	fseek(fichier,1,SEEK_CUR);
    while (fscanf(fichier, "%d:", &nombre) == 1)
    {
        Chainon **Temp = (Chainon**) realloc (Pietri.Arcs, sizeof(Chainon*)*(Pietri.nombreArcs+1));
        if (Temp == NULL)
        {
            perror ("realloc a echoue lors de la lecture de la ligne \"Place\" ");
            /* Faire une action, a toi de voir (Quitter, continuer ?) */
        }
        else
        {
            Pietri.Arcs = Temp;
            Pietri.Arcs[Pietri.nombreArcs] = NULL;
 
 
            /* On insere tout les arcs chaines */
            int numeroArc;
            if (fscanf(fichier, "%d ", &numeroArc) == 1)
            {
                Pietri.Arcs[Pietri.nombreArcs] = (Chainon*) malloc (sizeof(Chainon));
 
                Pietri.Arcs[Pietri.nombreArcs]->indiceSommet = numeroArc;
                //Pietri.Arcs[Pietri.nombreArcs]->nombreJetons
                Pietri.Arcs[Pietri.nombreArcs]->suivant = NULL;
                //Pietri.Arcs[Pietri.nombreArcs]->type
 
                Chainon* pointeur = Pietri.Arcs[Pietri.nombreArcs];
 
                while (fscanf(fichier, "%d ", &numeroArc) == 1)
                {
                    Chainon *nouveau = (Chainon*) malloc (sizeof(Chainon));
                    nouveau->indiceSommet = numeroArc;
                    //nouveau->nombreJetons
                    nouveau->suivant = NULL;
                    //nouveau->type
 
                    pointeur->suivant = nouveau;
                    pointeur = nouveau;
                }
 
            }
 
            Pietri.nombreArcs++;
            fseek(fichier,1,SEEK_CUR);
        }
    }
 
 
    int i;
    for (i=0 ; i<Pietri.nombreArcs ; i++)
    {
        printf("%d:", i);
        Chainon* parcours;
        for (parcours=Pietri.Arcs[i] ; parcours!=NULL ; parcours=parcours->suivant)
            printf("%d ", parcours->indiceSommet);
        printf("\n");
    }
 
 
 
 
    return EXIT_SUCCESS;
}

et voici la tete que dois avoir le fichier d'entre, noté qu'il faut que chaque ligne se termine par '*' (ca aussi c'est crade, mais ca va vite et c'est simple).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
1 2 3 7 8 9 *
4 5 6 10 11 *
1:4 *
2:4 6 *
3:6 *
4:7 *
5:2 *
6:9 *
7:10 *
8:5 *
9:11 *
10:1 8 *
11:3 8 *

25/11/2009, 21h48
Pouet_forever

C'est assez lourd comme fichier :?
Tu pourrais découper ton code en fonctions, ce qui te permettrait d'avoir plus de facilités pour ajouter / supprimer des maillons dans ta liste chaînée. Et aussi de lire plus facilement tes données ;)
Au lieux d'utiliser fscanf tu pourrais utiliser fgets avec des appels successifs à strtol en récupérant le deuxième argument de strtol. Ca t'éviterais de mettre des * à la fin de chaque ligne :)