Un Tableau de Structure en C ?

**mohsenuss91** · 12/12/2013, 19h18

Salut!
Je voulais faire une structure comme ceci:

Code :

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

1
2
3
4
5
6
7
8
9
/*structure noeud ab*/
 
struct noeud {
  int grille[9];
  int niv;
noeud pred[1];
noeud succ[4];
};
typedef struct noeud  *ab;

C'est à dire chaque noeud à :
-un tableau de 9 entier
-un niveau
- un tableau qui contient un noeud(prédécesseur)
- un tableau qui contient 4 noeuds (successeurs)
Mais j'ai un probléme au niveau de:

Code :

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

1
2
noeud pred[1];
noeud succ[4];

Comment faire svp!

**Neckara** · 13/12/2013, 06h29

Bonjour,

Ce serait bien de nous donner les messages d'erreurs...

Code :

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

1
2
3
4
5
6
7
8
9
/*structure noeud ab*/
 
typedef struct s_Noeud { // on évite d'avoir le même nom pour le struct et le typedef.
  int grille[9];
  int niv;
struct s_Noeud pred[1];
struct s_Noeud succ[4];
} Noeud; // Ainsi tu as un type "Noeud"
typedef struct noeud  *ab; //ab est un nom qui est très loin d'être explicite

second choix :

Code :

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

1
2
3
4
5
6
7
8
typedef struct s_Noeud Noeud;
 
struct s_Noeud
{
            //....
           Noeud pred[1];
           Noeud succ[4];
}

A noter que tu peux éventuellement remplacer Noeud pred[1] par Noeud pred.

Essaye aussi de mettre des majuscules à tes noms de types.

**mohsenuss91** · 13/12/2013, 08h48

Je voulais faire un programme en C qui fait la création d'un arbre qui à comme racine un nœud qui à un tableau de 9 entiers (etat initial ) et ces successeurs représente les permutation possible de 0 sachant que 0 peut faire une permutation qu'avec les cases adjacentes;

Voila j'ai modifié le code précédent:

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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
#include<stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
 
/******************************************************************************/
int start[] = {1,2,3,4,0,5,7,8,6};
int goal[] = {1,2,3,4,5,6,7,8,0};
//structure Liste entier
struct sElt {
    int val ;
    struct sElt *suiv ;
}Elt;
typedef struct sElt* Liste;
 
 
/* Cr?ation d'un nouvel ?l?ment */
Liste creation(int vval)
{    Liste e =  malloc(sizeof(e));
    if(e!=NULL) {
        e->val = vval ;
        e->suiv = NULL ;
    }
    return e ;
}
 
/*insert en queu */
void enfiler_l_int(Liste* l,int ve)
{   Liste  e=NULL,q = *l ; ;
    e=creation(ve);
 
    if(q==NULL) {*l =e;}
    else {
 
       while(q->suiv!=NULL) q = q->suiv ;
        q->suiv = e ;
    }
}
 
 
 
/*xxxxxxxxxxxx DENILER UN Noeud DANS LA Liste xxxxxxxx*/
Liste defiler_l_int(Liste* l)
{
Liste p=*l, q=p->suiv;
if(p!=NULL){
            *l=q;
            p->suiv=NULL;
            return p;
            free(p);
            }
 
}
 
//afficher un tAbrleau
void afficher_tAbr(int t[])
{int i;
     for(i=0;i<9;i++)
     {
      if((i%3)==0)   { printf("\n[ %d ]",t[i]);}
 
             else {printf("[ %d ]",t[i]);}
             }
     }
 
//test l'egalite de deux grilles
int egal_tAbr(int t1[],int t2[])
{int i;
int c=0;
     for(i=0;i<9;i++)
     {if(t1[i]!=t2[i]){c++;}
 
 
     }
     if(c==0) {return 1;}
     else {return 0;}
}
 
//permuatation de deux entiers
void permutation(int* a, int* b)
{
int t;
t=*a;
*a=*b;
*b=t;
 
}
 
//recherche d'un indice dun entier dans un tAbrleau
int rech_ind_ent(int t[9],int x)
	{int ind = 10;
	int i=0;
		for (i=0;i<9;i++){
			if (t[i]==x) ind=i;
		}
		return ind;
 
	}
 
 
Liste Test_permut(int g)
	{
	Liste pp=NULL;
 
 
	switch (g)
	{
	case 0:
	{
		enfiler_l_int(&pp,1);
		enfiler_l_int(&pp,3);
	break;}
 
	case 1:
	{
		enfiler_l_int(&pp,0);
		enfiler_l_int(&pp,2);
		enfiler_l_int(&pp,4);
	break;}
 
 
	case 2:
	{
		enfiler_l_int(&pp,1);
		enfiler_l_int(&pp,5);
	break;}
 
	case 3:
	{
		enfiler_l_int(&pp,0);
		enfiler_l_int(&pp,4);
		enfiler_l_int(&pp,6);
 
	break;}
 
	case 4:
	{
		enfiler_l_int(&pp,1);
		enfiler_l_int(&pp,3);
		enfiler_l_int(&pp,5);
		enfiler_l_int(&pp,7);
 
	break;}
 
	case 5:
	{
		enfiler_l_int(&pp,2);
		enfiler_l_int(&pp,4);
		enfiler_l_int(&pp,8);
 
	break;
	}
 
	case 6:
	{
	enfiler_l_int(&pp,3);
	enfiler_l_int(&pp,7);
	break;}
 
	case 7:
	{
	enfiler_l_int(&pp,4);
	enfiler_l_int(&pp,6);
	enfiler_l_int(&pp,8);
 
	break;}
 
	case 8:
	{
	enfiler_l_int(&pp,5);
	enfiler_l_int(&pp,7);
	break;}
	default:{};
	}
 
		return pp;
	}
 
 
/******************************************************************************/
/*structure Noeud Abr*/
struct sNoeud {
  int grille[9];
  int niv;
  struct sNoeud* pred[1];
  struct sNoeud* succ[4];
 
}Neoud;
typedef struct sNoeud  *Abr;
 
//creation d'un arbre
Abr creation_Abr(int vval[])
{    Abr e  = malloc(sizeof(*e));
    e->pred[0]=NULL;
    e->succ[0]=NULL;
	e->succ[1]=NULL;
	e->succ[2]=NULL;
	e->succ[3]=NULL;
    if(e!=NULL) {
        int i;
    for(i=0;i<9;i++){e->grille[i] = vval[i] ;}
 
    }
    return e ;
}
 
//Afficher un arbre
void affich_Abr(Abr r)
{
  if (r != NULL) {printf("\n* * * * * * * * *");
                    afficher_tAbr(r->grille);}
if (r->succ[0] != NULL) {affich_Abr(r->succ[0]);}
if (r->succ[1] != NULL) {affich_Abr(r->succ[1]);}
if (r->succ[2] != NULL) {affich_Abr(r->succ[2]);}
if (r->succ[3] != NULL) {affich_Abr(r->succ[3]);}
 
 
 
}
 
/*xxxxxxxxxxxx ENFILER UN Noeud DANS LA Abr xxxxxxxx*/
void enfiler_n_Abr(Abr* l,Abr e)
{   Abr  q = *l ;
 
    if(q==NULL) {*l =e;}
    else {
       while(q->succ[0]!=NULL) {q = q->succ[0] ;}
        q->succ[0] = e ;
    }
}
/*xxxxxxxxxxxx ENPILER UN Noeud DANS LA Abr xxxxxxxx*/
void empiler_n_Abr(Abr* l,Abr e)
{   Abr  q = *l ;
 
    if(q==NULL) {*l =e;}
    else {
        e->succ[0] = q ;
        q->pred[0]=e;
        *l =e;
    }
}
 
/*xxxxxxxxxxxx DEFILER UN Noeud DANS LA Abr xxxxxxxx*/
Abr defiler_n_Abr(Abr* l)
{
Abr p=*l, q=p->succ[0];
if(p!=NULL){
            *l=q;
            p->succ[0]=NULL;
            return p;
            free(p);
            }
 
}
 
 
//Successeur dun Noeud
void successeur(Abr* r)
{
    Abr q=*r;
 if(q!=NULL)
 {
 
 Liste pp=Test_permut(rech_ind_ent(q->grille,0));
 
 if(pp!=NULL)
 {
     Liste ds1=defiler_l_int(&pp);
     if(ds1!=NULL)
     {q->succ[0]=creation_Abr(q->grille);
     q->succ[0]->niv=q->niv+1;
     permutation(&q->succ[0]->grille[rech_ind_ent(q->succ[0]->grille,0)],&q->succ[0]->grille[ds1->val]);
      q->succ[0]->pred[0]=q;
         }
         Liste ds2=defiler_l_int(&pp);
     if(ds2!=NULL)
     {q->succ[1]=creation_Abr(q->grille);
     q->succ[1]->niv=q->niv+1;
     permutation(&q->succ[1]->grille[rech_ind_ent(q->succ[1]->grille,0)],&q->succ[1]->grille[ds2->val]);
    q->succ[1]->pred[0]=q;
         }
      Liste ds3=defiler_l_int(&pp);
     if(ds3!=NULL)
     {q->succ[2]=creation_Abr(q->grille);
     q->succ[2]->niv=q->niv+1;
     permutation(&q->succ[2]->grille[rech_ind_ent(q->succ[2]->grille,0)],&q->succ[2]->grille[ds3->val]);
        q->succ[2]->pred[0]=q;
         }
               Liste ds4=defiler_l_int(&pp);
     if(ds4!=NULL)
     {q->succ[3]=creation_Abr(q->grille);
     q->succ[3]->niv=q->niv+1;
     permutation(&q->succ[3]->grille[rech_ind_ent(q->succ[3]->grille,0)],&q->succ[3]->grille[ds4->val]);
        q->succ[3]->pred[0]=q;
         }
 
    }
}
 
if((q->succ[0]!=NULL)&&(egal_tAbr(q->succ[0]->grille,goal)==0)){successeur(&q->succ[0]);}
 
}
 
 
//******************************************
/*PROGRAMME PRINCIPAL*/
main()
{
 
Abr n=creation_Abr(start);
 
successeur(&n);
affich_Abr(n);
}

Mais j'ai toujours un problème au niveau de l'appel recursive de la procedure successeur() sur le premier nœud successeur q->succ[0] :

Code :

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

if((q->succ[0]!=NULL)&&(egal_tAbr(q->succ[0]->grille,goal)==0)){successeur(&q->succ[0]);}

PS: voila une image qui explique ce que je veux faire:

**Sve@r** · 13/12/2013, 09h56

Salut
Ce topic fait doublon avec celui-ci http://www.developpez.net/forums/d14...e-pointeurs-c/ où je t'avais déjà expliqué que
1) on ne masque pas un pointeur dans un nom de type
2) des noms comme "ab" ce n'est pas terrible
Si tu veux pas écouter ce qu'on te dit ce n'est pas la peine de venir sur un forum. Mais ce n'est pas en reposant 50 fois la même question que tu auras des réponses différentes.

Sinon je ne comprends pas comment, en ne permutant que 0, tu peux atteindre ton but. Que se passe-t-il si ton départ est
087
654
321
Comment, en ne permutant que 0, tu pourras atteindre
123
456
780
???

**mohsenuss91** · 13/12/2013, 10h47

J'ai fais ça mais ça marche pas:

Code :

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

1
2
3
4
5
6
//structure Liste d'entiers
struct sElt {
    int val ;
    struct sElt *suiv ;
}Elt;
typedef Elt* Liste;

une erreur de type:

Code :

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

 warning: data definition has no type or storage class|

dans la ligne:

Code :

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

typedef Elt* Liste;

à ce qui concerne la parmutation de 0,
0 represente la case vide et c'est la seule case qu'en a le droit d'utiliser pour faire la permutation (avec les cases qui sont adjacentes à 0).

c'est vrais la solution ne sera pas rapide, mais je doit respecté cette contrainte.

**Médinoc** · 13/12/2013, 11h07

Envoyé par Neckara

Bonjour,

Ce serait bien de nous donner les messages d'erreurs...

Code :

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

1
2
3
4
5
6
7
8
9
/*structure noeud ab*/
 
typedef struct s_Noeud { // on évite d'avoir le même nom pour le struct et le typedef.
  int grille[9];
  int niv;
struct s_Noeud pred[1];
struct s_Noeud succ[4];
} Noeud; // Ainsi tu as un type "Noeud"
typedef struct noeud  *ab; //ab est un nom qui est très loin d'être explicite

second choix :

Code :

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

1
2
3
4
5
6
7
8
typedef struct s_Noeud Noeud;
 
struct s_Noeud
{
            //....
           Noeud pred[1];
           Noeud succ[4];
}

A noter que tu peux éventuellement remplacer Noeud pred[1] par Noeud pred.

Essaye aussi de mettre des majuscules à tes noms de types.

Dans tous les cas ça va foirer, car on ne peut pas inclure une structure dans elle-même: Il va falloir utiliser des pointeurs.

**diogene** · 13/12/2013, 11h09

Elt est ici une variable du type struct sElt. Ce nest pas une définition de type.
Or un type est attendu dans typedef Elt* Liste; .

Code :

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

1
2
3
4
5
6
//structure Liste d'entiers
typedef struct sElt {
    int val ;
    struct sElt *suiv ;
}Elt;
typedef Elt* Liste;

**mohsenuss91** · 13/12/2013, 11h23

OK, j'ai changé le code a ce qui concerne les structures:

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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
#include<stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
 
/******************************************************************************/
int start[] = {1,2,3,4,0,5,7,8,6};
int goal[] = {1,2,3,4,5,6,7,8,0};
 
//structure Liste d'entiers
//structure Liste d'entiers
typedef struct sElt {
    int val ;
    struct sElt *suiv ;
}Elt;
typedef Elt* Liste;
 
 
/* Creation d'un nouvel element qui va contenir un entier*/
Liste creation(int vval)
{    Liste e =  malloc(sizeof(e));
    if(e!=NULL) {
        e->val = vval ;
        e->suiv = NULL ;
    }
    return e ;
}
 
/*inserer un element en queu de la Liste d'entiers*/
void enfiler_l_int(Liste* l,int ve)
{   Liste  e=NULL,q = *l ; ;
    e=creation(ve);
 
    if(q==NULL) {*l =e;}
    else {
 
       while(q->suiv!=NULL) q = q->suiv ;
        q->suiv = e ;
    }
}
//inserer un element en tete de la Liste d'entiers
void empiler_l_int(Liste* l,Liste e)
{   Liste  q = *l ; ;
 
 
    if(q==NULL) {*l =e;}
    else {
        e->suiv = q ;
        *l =e;
    }
}
 
 
 
 
/*Defiler un element de la tete de la Liste d'entiers*/
Liste defiler_l_int(Liste* l)
{
Liste p=*l, q=p->suiv;
if(p!=NULL){
            *l=q;
            p->suiv=NULL;
            return p;
            free(p);
            }
 
}
 
//afficher un tableau d'entiers
void afficher_tab(int t[])
{int i;
     for(i=0;i<9;i++)
     {
      if((i%3)==0)   { printf("\n[ %d ]",t[i]);}
 
             else {printf("[ %d ]",t[i]);}
             }
     }
 
//test l'egalite de deux tableaux d'entier
int egal_tab(int t1[],int t2[])
{int i;
int c=0;
     for(i=0;i<9;i++)
     {if(t1[i]!=t2[i]){c++;}
 
 
     }
     if(c==0) {return 1;}
     else {return 0;}
}
 
//permuatation de deux entiers
void permutation(int* a, int* b)
{
int t;
t=*a;
*a=*b;
*b=t;
 
}
 
//rechercher l'indice d'un entier dans un tableau
int rech_ind_ent(int t[9],int x)
	{int ind = 10;
	int i=0;
		for (i=0;i<9;i++){
			if (t[i]==x) ind=i;
		}
		return ind;
 
	}
 
//tester les permutation possible de la case qui à l'indice comme parametre dans la fonction
Liste Test_permut(int g)
	{
	Liste pp=NULL;
 
 
	switch (g)
	{
	case 0:
	{
		enfiler_l_int(&pp,1);
		enfiler_l_int(&pp,3);
	break;}
 
	case 1:
	{
		enfiler_l_int(&pp,0);
		enfiler_l_int(&pp,2);
		enfiler_l_int(&pp,4);
	break;}
 
 
	case 2:
	{
		enfiler_l_int(&pp,1);
		enfiler_l_int(&pp,5);
	break;}
 
	case 3:
	{
		enfiler_l_int(&pp,0);
		enfiler_l_int(&pp,4);
		enfiler_l_int(&pp,6);
 
	break;}
 
	case 4:
	{
		enfiler_l_int(&pp,1);
		enfiler_l_int(&pp,3);
		enfiler_l_int(&pp,5);
		enfiler_l_int(&pp,7);
 
	break;}
 
	case 5:
	{
		enfiler_l_int(&pp,2);
		enfiler_l_int(&pp,4);
		enfiler_l_int(&pp,8);
 
	break;
	}
 
	case 6:
	{
	enfiler_l_int(&pp,3);
	enfiler_l_int(&pp,7);
	break;}
 
	case 7:
	{
	enfiler_l_int(&pp,4);
	enfiler_l_int(&pp,6);
	enfiler_l_int(&pp,8);
 
	break;}
 
	case 8:
	{
	enfiler_l_int(&pp,5);
	enfiler_l_int(&pp,7);
	break;}
	default:{};
	}
 
		return pp;
	}
 
 
/******************************************************************************/
/*structure Noeud Abr*/
typedef struct sNoeud {
  int grille[9];
  int niv;
  struct sNoeud* pred[1];
  struct sNoeud* succ[4];
 
}Neoud;
typedef Neoud* Abr;
 
 
//creation d'un Noeud
Abr creation_Abr(int vval[])
{    Abr e  = malloc(sizeof(*e));
    e->pred[0]=NULL;
    e->succ[0]=NULL;
	e->succ[1]=NULL;
	e->succ[2]=NULL;
	e->succ[3]=NULL;
    if(e!=NULL) {
        int i;
    for(i=0;i<9;i++){e->grille[i] = vval[i] ;}
 
    }
    return e ;
}
 
//Afficher un arbre
void affich_Abr(Abr r)
{
  if (r != NULL) {printf("\n* * * * * * * * *");
                    afficher_tab(r->grille);}
if (r->succ[0] != NULL) {affich_Abr(r->succ[0]);}
if (r->succ[1] != NULL) {affich_Abr(r->succ[1]);}
if (r->succ[2] != NULL) {affich_Abr(r->succ[2]);}
if (r->succ[3] != NULL) {affich_Abr(r->succ[3]);}
 
}
 
/*ENFILER UN Noeud DANS L'Abr */
void enfiler_n_Abr(Abr* l,Abr e)
{   Abr  q = *l ;
 
    if(q==NULL) {*l =e;}
    else {
       while(q->succ[0]!=NULL) {q = q->succ[0] ;}
        q->succ[0] = e ;
    }
}
/*ENPILER UN Noeud DANS l'Abr */
void empiler_n_Abr(Abr* l,Abr e)
{   Abr  q = *l ;
 
    if(q==NULL) {*l =e;}
    else {
        e->succ[0] = q ;
        q->pred[0]=e;
        *l =e;
    }
}
 
/*DEFILER UN Noeud DANS L'Abr*/
Abr defiler_n_Abr(Abr* l)
{
Abr p=*l, q=p->succ[0];
if(p!=NULL){
            *l=q;
            p->succ[0]=NULL;
            return p;
            free(p);
            }
 
}
 
 
//Creer les Successeurs dun Noeud
void successeur(Abr* r)
{
    Abr q=*r;
 if(q!=NULL)
 {
 
 Liste pp=Test_permut(rech_ind_ent(q->grille,0));
 
 if(pp!=NULL)
 {
     Liste ds1=defiler_l_int(&pp);
     if(ds1!=NULL)
     {q->succ[0]=creation_Abr(q->grille);
     q->succ[0]->niv=q->niv+1;
     permutation(&q->succ[0]->grille[rech_ind_ent(q->succ[0]->grille,0)],&q->succ[0]->grille[ds1->val]);
      q->succ[0]->pred[0]=q;
         }
         Liste ds2=defiler_l_int(&pp);
     if(ds2!=NULL)
     {q->succ[1]=creation_Abr(q->grille);
     q->succ[1]->niv=q->niv+1;
     permutation(&q->succ[1]->grille[rech_ind_ent(q->succ[1]->grille,0)],&q->succ[1]->grille[ds2->val]);
    q->succ[1]->pred[0]=q;
         }
      Liste ds3=defiler_l_int(&pp);
     if(ds3!=NULL)
     {q->succ[2]=creation_Abr(q->grille);
     q->succ[2]->niv=q->niv+1;
     permutation(&q->succ[2]->grille[rech_ind_ent(q->succ[2]->grille,0)],&q->succ[2]->grille[ds3->val]);
        q->succ[2]->pred[0]=q;
         }
               Liste ds4=defiler_l_int(&pp);
     if(ds4!=NULL)
     {q->succ[3]=creation_Abr(q->grille);
     q->succ[3]->niv=q->niv+1;
     permutation(&q->succ[3]->grille[rech_ind_ent(q->succ[3]->grille,0)],&q->succ[3]->grille[ds4->val]);
        q->succ[3]->pred[0]=q;
         }
 
    }
}
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
if((q->succ[0]!=NULL)&&(egal_tab(q->succ[0]->grille,goal)==0)){successeur(&q->succ[0]);}
 
}
 
 
 
 
/*PROGRAMME PRINCIPAL*/
main()
{
 
Abr n=creation_Abr(start);
 
successeur(&n);
affich_Abr(n);
}

Mais il y a toujours un problème dans Successeur() au niveau de la ligne:

Code :

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

if((q->succ[0]!=NULL)&&(egal_tab(q->succ[0]->grille,goal)==0)){successeur(&q->succ[0]);}

**Médinoc** · 13/12/2013, 11h38

Code :

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

Liste e =  malloc(sizeof(e));

Boum!

Code :

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

Liste e =  malloc(sizeof(*e));

**Neckara** · 13/12/2013, 12h51

Envoyé par Médinoc

Dans tous les cas ça va foirer, car on ne peut pas inclure une structure dans elle-même: Il va falloir utiliser des pointeurs.

En effet, je m'étais surtout concentré sur le fait que le compilateur ne reconnaissait pas "Noeud" comme un nom de type.

**mohsenuss91** · 13/12/2013, 14h00

J'ai modifié un peu le 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
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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
#include<stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
 
/******************************************************************************/
int start[] = {1,2,3,4,0,5,7,8,6};
int goal[] = {1,2,3,4,5,6,7,8,0};
 
//structure Liste d'entiers
//structure Liste d'entiers
typedef struct sElt {
    int val ;
    struct sElt *suiv ;
}Elt;
typedef Elt* Liste;
 
 
/* Creation d'un nouvel element qui va contenir un entier*/
Liste creation(int vval)
{    Liste e =  malloc(sizeof(*e));
    if(e!=NULL) {
        e->val = vval ;
        e->suiv = NULL ;
    }
    return e ;
}
 
/*inserer un element en queu de la Liste d'entiers*/
void enfiler_l_int(Liste* l,int ve)
{   Liste  e=NULL,q = *l ; ;
    e=creation(ve);
 
    if(q==NULL) {*l =e;}
    else {
 
       while(q->suiv!=NULL) q = q->suiv ;
        q->suiv = e ;
    }
}
//inserer un element en tete de la Liste d'entiers
void empiler_l_int(Liste* l,Liste e)
{   Liste  q = *l ; ;
 
 
    if(q==NULL) {*l =e;}
    else {
        e->suiv = q ;
        *l =e;
    }
}
 
 
 
 
/*Defiler un element de la tete de la Liste d'entiers*/
Liste defiler_l_int(Liste* l)
{
Liste p=*l, q=p->suiv;
if(p!=NULL){
            *l=q;
            p->suiv=NULL;
            return p;
            free(p);
            }
 
}
 
//afficher un tableau d'entiers
void afficher_tab(int t[])
{int i;
     for(i=0;i<9;i++)
     {
      if((i%3)==0)   { printf("\n[ %d ]",t[i]);}
 
             else {printf("[ %d ]",t[i]);}
             }
     }
 
//test l'egalite de deux tableaux d'entier
int egal_tab(int t1[],int t2[])
{int i;
int c=0;
     for(i=0;i<9;i++)
     {if(t1[i]!=t2[i]){c++;}
 
 
     }
     if(c==0) {return 1;}
     else {return 0;}
}
 
//permuatation de deux entiers
void permutation(int* a, int* b)
{
int t;
t=*a;
*a=*b;
*b=t;
 
}
 
//rechercher l'indice d'un entier dans un tableau
int rech_ind_ent(int t[9],int x)
	{int ind = 10;
	int i=0;
		for (i=0;i<9;i++){
			if (t[i]==x) ind=i;
		}
		return ind;
 
	}
 
//tester les permutation possible de la case qui à l'indice comme parametre dans la fonction
Liste Test_permut(int g)
	{
	Liste pp=NULL;
 
 
	switch (g)
	{
	case 0:
	{
		enfiler_l_int(&pp,1);
		enfiler_l_int(&pp,3);
	break;}
 
	case 1:
	{
		enfiler_l_int(&pp,0);
		enfiler_l_int(&pp,2);
		enfiler_l_int(&pp,4);
	break;}
 
 
	case 2:
	{
		enfiler_l_int(&pp,1);
		enfiler_l_int(&pp,5);
	break;}
 
	case 3:
	{
		enfiler_l_int(&pp,0);
		enfiler_l_int(&pp,4);
		enfiler_l_int(&pp,6);
 
	break;}
 
	case 4:
	{
		enfiler_l_int(&pp,1);
		enfiler_l_int(&pp,3);
		enfiler_l_int(&pp,5);
		enfiler_l_int(&pp,7);
 
	break;}
 
	case 5:
	{
		enfiler_l_int(&pp,2);
		enfiler_l_int(&pp,4);
		enfiler_l_int(&pp,8);
 
	break;
	}
 
	case 6:
	{
	enfiler_l_int(&pp,3);
	enfiler_l_int(&pp,7);
	break;}
 
	case 7:
	{
	enfiler_l_int(&pp,4);
	enfiler_l_int(&pp,6);
	enfiler_l_int(&pp,8);
 
	break;}
 
	case 8:
	{
	enfiler_l_int(&pp,5);
	enfiler_l_int(&pp,7);
	break;}
	default:{};
	}
 
		return pp;
	}
 
 
/******************************************************************************/
/*structure Noeud Abr*/
typedef struct sNoeud {
  int grille[9];
  int niv;
  struct sNoeud* pr;
  struct sNoeud* s1;
  struct sNoeud* s2;
   struct sNoeud* s3;
   struct sNoeud* s4;
 
}Neoud;
typedef Neoud* Abr;
 
 
//creation d'un Noeud
Abr creation_Abr(int vval[])
{    Abr e  = malloc(sizeof(*e));
    e->pr=NULL;
    e->s1=NULL;
	e->s2=NULL;
	e->s3=NULL;
	e->s4=NULL;
    if(e!=NULL) {
        int i;
    for(i=0;i<9;i++){e->grille[i] = vval[i] ;}
 
    }
    return e ;
}
 
//Afficher un arbre
void affich_Abr(Abr r)
{
  if (r != NULL) {printf("\n* * * * * * * * *");
                    afficher_tab(r->grille);}
if (r->s1 != NULL) {affich_Abr(r->s1);}
if (r->s2 != NULL) {affich_Abr(r->s2);}
if (r->s3 != NULL) {affich_Abr(r->s3);}
if (r->s4 != NULL) {affich_Abr(r->s4);}
 
}
 
/*ENFILER UN Noeud DANS L'Abr */
void enfiler_n_Abr(Abr* l,Abr e)
{   Abr  q = *l ;
 
    if(q==NULL) {*l =e;}
    else {
       while(q->s1!=NULL) {q = q->s1 ;}
        q->s1 = e ;
    }
}
/*ENPILER UN Noeud DANS l'Abr */
void empiler_n_Abr(Abr* l,Abr e)
{   Abr  q = *l ;
 
    if(q==NULL) {*l =e;}
    else {
        e->s1 = q ;
        q->pr=e;
        *l =e;
    }
}
 
/*DEFILER UN Noeud DANS L'Abr*/
Abr defiler_n_Abr(Abr* l)
{
Abr p=*l, q=p->s1;
if(p!=NULL){
            *l=q;
            p->s1=NULL;
            return p;
            free(p);
            }
 
}
 
 
//Creer les Successeurs dun Noeud
void successeur(Abr* r)
{
    Abr q=*r;
 if(q!=NULL)
 {
 
 Liste pp=Test_permut(rech_ind_ent(q->grille,0));
 
 if(pp!=NULL)
 {
     Liste ds1=defiler_l_int(&pp);
     if(ds1!=NULL)
     {q->s1=creation_Abr(q->grille);
     q->s1->niv=q->niv+1;
     permutation(&q->s1->grille[rech_ind_ent(q->s1->grille,0)],&q->s1->grille[ds1->val]);
      q->s1->pr=q;
         }
         Liste ds2=defiler_l_int(&pp);
     if(ds2!=NULL)
     {q->s2=creation_Abr(q->grille);
     q->s2->niv=q->niv+1;
     permutation(&q->s2->grille[rech_ind_ent(q->s2->grille,0)],&q->s2->grille[ds2->val]);
    q->s2->pr=q;
         }
      Liste ds3=defiler_l_int(&pp);
     if(ds3!=NULL)
     {q->s3=creation_Abr(q->grille);
     q->s3->niv=q->niv+1;
     permutation(&q->s3->grille[rech_ind_ent(q->s3->grille,0)],&q->s3->grille[ds3->val]);
        q->s3->pr=q;
         }
               Liste ds4=defiler_l_int(&pp);
     if(ds4!=NULL)
     {q->s4=creation_Abr(q->grille);
     q->s4->niv=q->niv+1;
     permutation(&q->s4->grille[rech_ind_ent(q->s4->grille,0)],&q->s4->grille[ds4->val]);
        q->s4->pr=q;
         }
 
    }
}
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
if((q->s1!=NULL)&&(egal_tab(q->s1->grille,goal)==0)){successeur(&q->s1);}
 
}
 
 
 
 
/*PROGRAMME PRINCIPAL*/
main()
{
Abr n=creation_Abr(start);
successeur(&n);
affich_Abr(n);
}

Mais il y a un problème au niveau de la procédure successeur() dans la ligne suivante:

Code :

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

if((q->s1!=NULL)&&(egal_tab(q->s1->grille,goal)==0)){successeur(&q->s1);}

Je comprends pas pourquoi? Aidez mois svp !

**Médinoc** · 13/12/2013, 14h09

Ce test semble être hors du if(q != NULL).

PS: Ce code est indenté comme l'as de pique...

**mohsenuss91** · 13/12/2013, 14h17

Envoyé par Médinoc

Ce test semble être hors du if(q != NULL).

PS: Ce code est indenté comme l'as de pique...

même comme ça:

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
void successeur(Abr* r)
{
    Abr q=*r;
 if(q!=NULL)
 {
 
 Liste pp=Test_permut(rech_ind_ent(q->grille,0));
 
 if(pp!=NULL)
 {
     Liste ds1=defiler_l_int(&pp);
     if(ds1!=NULL)
     {q->s1=creation_Abr(q->grille);
     q->s1->niv=q->niv+1;
     permutation(&q->s1->grille[rech_ind_ent(q->s1->grille,0)],&q->s1->grille[ds1->val]);
      q->s1->pr=q;
         }
         Liste ds2=defiler_l_int(&pp);
     if(ds2!=NULL)
     {q->s2=creation_Abr(q->grille);
     q->s2->niv=q->niv+1;
     permutation(&q->s2->grille[rech_ind_ent(q->s2->grille,0)],&q->s2->grille[ds2->val]);
    q->s2->pr=q;
         }
      Liste ds3=defiler_l_int(&pp);
     if(ds3!=NULL)
     {q->s3=creation_Abr(q->grille);
     q->s3->niv=q->niv+1;
     permutation(&q->s3->grille[rech_ind_ent(q->s3->grille,0)],&q->s3->grille[ds3->val]);
        q->s3->pr=q;
         }
               Liste ds4=defiler_l_int(&pp);
     if(ds4!=NULL)
     {q->s4=creation_Abr(q->grille);
     q->s4->niv=q->niv+1;
     permutation(&q->s4->grille[rech_ind_ent(q->s4->grille,0)],&q->s4->grille[ds4->val]);
        q->s4->pr=q;
         }
 
    }
 
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
if((q->s1!=NULL)&&(egal_tab(q->s1->grille,goal)==0)){successeur(&q->s1);}
}
}

ça marche pas

**Sve@r** · 13/12/2013, 15h10

Envoyé par Médinoc

PS: Ce code est indenté comme l'as de pique...

C'est ce que je lui ai dit (entre autres) ici http://www.developpez.net/forums/d14...c/#post7609154 mais il s'obstine à ne pas vouloir prendre en compte nos remarques et à reposer sans cesse la même question. Pfff

**mohsenuss91** · 13/12/2013, 18h43

Envoyé par Sve@r

C'est ce que je lui ai dit (entre autres) ici http://www.developpez.net/forums/d14...c/#post7609154 mais il s'obstine à ne pas vouloir prendre en compte nos remarques et à reposer sans cesse la même question. Pfff

Désolé, j'essai a chaque fois de suivre vous conseils et d'améliorer le 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
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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
 
#include<stdio.h>
#include <stdlib.h>
 
 
/******************************************************************************/
int start[] = {1,2,3,4,0,5,7,8,6};
int goal[] = {1,2,3,4,5,6,7,8,0};
int one[]={1,2,2,3,4,5,2,6,7};
//structure Liste d'entiers
//structure Liste d'entiers
typedef struct sElt {
    int val ;
    struct sElt *suiv ;
                    }Elt;
typedef Elt* Liste;
 
 
/* Creation d'un nouvel element qui va contenir un entier*/
Liste creation(int vval)
{    Liste e =  malloc(sizeof(*e));
    if(e!=NULL) {
                    e->val = vval ;
                    e->suiv = NULL ;
                }
    return e ;
}
 
/*inserer un element en queu de la Liste d'entiers*/
void emfiler_l_int(Liste* l,int ve)
{   Liste  e=NULL,q = *l ; ;
    e=creation(ve);
 
    if(q==NULL) {*l =e;}
    else {
 
            while(q->suiv!=NULL) q = q->suiv ;
            q->suiv = e ;
        }
}
 
//inserer un element en tete de la Liste d'entiers
void empiler_l_int(Liste* l,int ve)
{   Liste  e=creation(ve),q = *l ; ;
 
 
    if(q==NULL) {*l =e;}
    else {
 
            e->suiv=q;
            *l =e;
        }
}
 
 
 
 
 
//Defiler un element de la tete de la Liste d'entiers
Liste defiler_l_int(Liste* l)
{
Liste p=*l, q=p->suiv;
if(p!=NULL){
            *l=q;
            p->suiv=NULL;
 
            }
return p;
free(p);
}
 
//afficher un tableau d'entiers
void afficher_tab(int t[])
{int i;
     for(i=0;i<9;i++)
            {
                if((i%3)==0)   { printf("\n[ %d ]",t[i]);}
 
                else {printf("[ %d ]",t[i]);}
             }
     }
 
//test l'egalite de deux tableaux d'entier
int egal_tab(int t1[],int t2[])
{int i;
int c=0;
     for(i=0;i<9;i++)
     {if(t1[i]!=t2[i]){c++;}}
     if(c==0) {return 1;}
     else {return 0;}
}
 
//permuatation de deux entiers
void permutation(int* a, int* b)
{
int t;
t=*a;
*a=*b;
*b=t;
}
 
//rechercher l'indice d'un entier dans un tableau
int rech_ind_ent(int t[9],int x)
{   int ind = 10;
	int i=0;
    for (i=0;i<9;i++){if (t[i]==x) ind=i;}
		return ind;
 
}
 
//tester les permutation possible de la case qui à l'indice comme parametre dans la fonction
Liste Test_permut(int g)
{
	Liste pp=NULL;
 
if((g<9)&&(g>-1))
{
switch (g)
{
	case 0:
	{
		emfiler_l_int(&pp,1);
		emfiler_l_int(&pp,3);
	break;}
 
	case 1:
	{
		emfiler_l_int(&pp,0);
		emfiler_l_int(&pp,2);
		emfiler_l_int(&pp,4);
	break;}
 
 
	case 2:
	{
		emfiler_l_int(&pp,1);
		emfiler_l_int(&pp,5);
	break;}
 
	case 3:
	{
		emfiler_l_int(&pp,0);
		emfiler_l_int(&pp,4);
		emfiler_l_int(&pp,6);
 
	break;}
 
	case 4:
	{
		emfiler_l_int(&pp,1);
		emfiler_l_int(&pp,3);
		emfiler_l_int(&pp,5);
		emfiler_l_int(&pp,7);
 
	break;}
 
	case 5:
	{
		emfiler_l_int(&pp,2);
		emfiler_l_int(&pp,4);
		emfiler_l_int(&pp,8);
 
	break;
	}
 
	case 6:
	{
	emfiler_l_int(&pp,3);
	emfiler_l_int(&pp,7);
	break;}
 
	case 7:
	{
	emfiler_l_int(&pp,4);
	emfiler_l_int(&pp,6);
	emfiler_l_int(&pp,8);
 
	break;}
 
	case 8:
	{
	emfiler_l_int(&pp,5);
	emfiler_l_int(&pp,7);
	break;}
	default:{};
}
}
return pp;
}
 
 
//*****************************************************************************
//structure Noeud Abr
typedef struct sNoeud {
  int grille[9];
  int niv;
  struct sNoeud* pr;
  struct sNoeud* s1;
  struct sNoeud* s2;
   struct sNoeud* s3;
   struct sNoeud* s4;
                    }Neoud;
typedef Neoud* Abr;
 
 
//creation d'un Noeud
Abr creation_Abr(int vval[])
{ Abr e  = malloc(sizeof(*e));
    e->pr=NULL;
    e->s1=NULL;
	e->s2=NULL;
	e->s3=NULL;
	e->s4=NULL;
    if(e!=NULL) {
                    int i;
                    for(i=0;i<9;i++){e->grille[i] = vval[i] ;}
 
                }
    return e ;
}
 
//Afficher un arbre
void affich_Abr(Abr r)
{
  if (r != NULL) {
                    printf("\n* * * * * * * * *");
                    afficher_tab(r->grille);
                }
 
if (r->s1 != NULL) {affich_Abr(r->s1);}
if (r->s2 != NULL) {affich_Abr(r->s2);}
if (r->s3 != NULL) {affich_Abr(r->s3);}
if (r->s4 != NULL) {affich_Abr(r->s4);}
 
}
 
//ENFILER UN Noeud DANS L'Abr
void emfiler_n_Abr(Abr* l,int vval[])
{   Abr  q = *l ;
Abr e  = creation_Abr(vval);
    if(q==NULL) {*l =e;}
    else {
            while(q->s1!=NULL) {q = q->s1 ;}
            q->s1 = e ;
        }
}
 
//ENPILER UN Noeud DANS l'Abr
void empiler_n_Abr(Abr* l,int vval[])
{   Abr  q = *l ;
Abr e  = creation_Abr(vval);
 if(e!=NULL) {
                    int i;
                    for(i=0;i<9;i++){e->grille[i] = vval[i] ;}
 
                }
    if(q==NULL) {*l =e;}
    else {
            e->s1 = q ;
            q->pr=e;
            *l =e;
        }
}
 
//DEFILER UN Noeud DANS L'Abr
Abr defiler_n_Abr(Abr* l)
{
Abr p=*l, q=p->s1;
if(p!=NULL){
            *l=q;
            p->s1=NULL;
 
            }
return p;
free(p);
}
 
 
//Creer les Successeurs dun Noeud
void successeur(Abr* r)
{
Abr q=*r;
 
if(q!=NULL){
 
 Liste pp=Test_permut(rech_ind_ent(q->grille,0));
 
 if(pp!=NULL)
    {
     Liste ds1=defiler_l_int(&pp);
     if(ds1!=NULL)
        {
            q->s1=creation_Abr(q->grille);
            q->s1->niv=q->niv+1;
            permutation(&q->s1->grille[rech_ind_ent(q->s1->grille,0)],&q->s1->grille[ds1->val]);
            q->s1->pr=q;
        }
 
    Liste ds2=defiler_l_int(&pp);
     if(ds2!=NULL)
        {
            q->s2=creation_Abr(q->grille);
            q->s2->niv=q->niv+1;
            permutation(&q->s2->grille[rech_ind_ent(q->s2->grille,0)],&q->s2->grille[ds2->val]);
            q->s2->pr=q;
        }
 
    Liste ds3=defiler_l_int(&pp);
     if(ds3!=NULL)
        {
            q->s3=creation_Abr(q->grille);
            q->s3->niv=q->niv+1;
            permutation(&q->s3->grille[rech_ind_ent(q->s3->grille,0)],&q->s3->grille[ds3->val]);
            q->s3->pr=q;
        }
 
    Liste ds4=defiler_l_int(&pp);
     if(ds4!=NULL)
        {
            q->s4=creation_Abr(q->grille);
            q->s4->niv=q->niv+1;
            permutation(&q->s4->grille[rech_ind_ent(q->s4->grille,0)],&q->s4->grille[ds4->val]);
            q->s4->pr=q;
         }
 
    }
 
 
if((q->s1!=NULL)&&(egal_tab(q->s1->grille,goal)==0)){
                                                    successeur(&q->s1);
                                                    printf("SUCCESSEUR S1");
                                                    }
 
    }
}
 
 
 
/*PROGRAMME PRINCIPAL*/
int main()
{
Abr l=creation_Abr(start);
successeur(&l);
affich_Abr(l);
 
getch();
}

S'il y a un truc qui n'est pas claire mettez un post je vous répends

PS: J'ai essayé les fonctions et les procédures une par une,
le probléme est au niveau de successeur() "segmentation fault (core dumped)" sachant que j'ai testé si q->s1 est non NULL en affichant ça grille .

Code :

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

1
2
3
4
if((q->s1!=NULL)&&(egal_tab(q->s1->grille,goal)==0)){
                                                    successeur(&q->s1);
                                                    printf("SUCCESSEUR S1");
                                                    }

ça m'affiche " segmentation fault " sur UBUNTU

**Sve@r** · 14/12/2013, 19h42

Envoyé par mohsenuss91

Désolé, j'essai a chaque fois de suivre vous conseils et d'améliorer le code

Ah oui ? Pourtant je vois toujours ton type "Liste" masquer un pointeur. Quand à l'indentation...

Envoyé par mohsenuss91

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
//Defiler un element de la tete de la Liste d'entiers
Liste defiler_l_int(Liste* l)
{
Liste p=*l, q=p->suiv;
if(p!=NULL){
            *l=q;
            p->suiv=NULL;

            }
return p;
free(p);
}

S'il y a un truc qui n'est pas claire mettez un post je vous répends

Mouais. Tu m'expliques ce free() juste après le return ???
Pour le reste réécris ton code proprement et on t'aidera...

Il y a quand-même un truc qui m'étonne: tu dois gérer des tableaux, c.a.d. des trucs de ce type
012
345
678

Alors pourquoi gères-tu des valeurs ? Tu peux pas stocker tout le tableau en entier dans un noeud ???

**mohsenuss91** · 14/12/2013, 20h53

- Je vais essayé de réécrire le code et de l'amélioré a ce qui concerne le masquage de pointeurs et je vais mettre la dernière version une fois que je le termine.
- Le free(p) c'est parce que je veux supprimer le nœud une fois que j'ai récupéré sa valeur.
- Je stock tout le tableau dans le nœud et je fais le permutation

**Sve@r** · 14/12/2013, 21h27

Envoyé par mohsenuss91

- Le free(p) c'est parce que je veux supprimer le nœud une fois que j'ai récupéré sa valeur.

Ben déjà le free() ne sera pas exécuté vu que la fonction s'arrête au return ; et sinon ça sert à rien de récupérer quelque chose que tu supprimes dans la foulée...

Envoyé par mohsenuss91

Code c :

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

1
2
3
4
typedef struct sElt {
    int val ;
    struct sElt *suiv ;
}Elt;

- Je stock tout le tableau dans le nœud et je fais le permutation

Ben non, ton noeud ne stocke qu'un seul entier (int val). Et "un entier" ce n'est pas "un tableau" d'entiers...

**mohsenuss91** · 17/12/2013, 16h14

Envoyé par Sve@r

Ben déjà le free() ne sera pas exécuté vu que la fonction s'arrête au return ; et sinon ça sert à rien de récupérer quelque chose que tu supprimes dans la foulée...

Ben non, ton noeud ne stocke qu'un seul entier (int val). Et "un entier" ce n'est pas "un tableau" d'entiers...

OUPS! Je parle de ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
/*structure Noeud Abr*/
typedef struct sNoeud {
  int grille[9];
  int niv;
  struct sNoeud* pr;
  struct sNoeud* s1;
  struct sNoeud* s2;
   struct sNoeud* s3;
   struct sNoeud* s4;
 
}Neoud;
typedef Neoud* Abr;

**mohsenuss91** · 19/12/2013, 21h36

Note de la modération : le PO avait créé une seconde discussion pour parler du même problème mais avec une solution différente. Pour plus de cohérence, les deux conversations ont été fusionnées.

Envoyé par mohsenuss91

C'est le même problème mais j'ai changé la méthode de solution.
Dans le premier sujet j'utilise un arbre
Dans celui la j'utilise une file d'attente

Salut ! Je voulais faire un programme en C qui me donne la solution du jeu de Taquin3x3 (ou taquin 8 pieces)

La procédure de solution et la suivante :

- Je fais la création d'un nœud initial qui contient la grille initiale (qui représente initial)

- J'enfile le nœud dans la la file frontière

- Je test si le nœud est un nœud but alors je l'empile dans la pile solution et ces prédécesseurs (le chemin de la solution)

sinon j'enfile ces successeurs (qui représente le permutation possible de 0) dans la file frontière et je refais le test.

voila le 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
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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
#include<stdio.h>
#include <stdlib.h>
 
 
/******************************************************************************/
int start[] = {1,2,3,4,0,5,7,8,6};
int goal[] = {1,2,3,4,5,6,7,8,0};
 
 
//structure Liste d'entiers
typedef struct sElt {
    int val ;
    struct sElt *suiv ;
                    }Elt;
typedef Elt* Liste;
 
 
/* Creation d'un nouvel element qui va contenir un entier*/
Liste creation(int vval)
{    Liste e =  malloc(sizeof(*e));
    if(e!=NULL) {
                    e->val = vval ;
                    e->suiv = NULL ;
                }
    return e ;
}
 
/*inserer un element en queu de la Liste d'entiers*/
void emfiler_l_int(Liste* l,int ve)
{   Liste  e=NULL,q = *l ; ;
    e=creation(ve);
 
    if(q==NULL) {*l =e;}
    else {
 
            while(q->suiv!=NULL) q = q->suiv ;
            q->suiv = e ;
        }
}
 
//inserer un element en tete de la Liste d'entiers
void empiler_l_int(Liste* l,int ve)
{   Liste  e=creation(ve),q = *l ; ;
 
 
    if(q==NULL) {*l =e;}
    else {
 
            e->suiv=q;
            *l =e;
        }
}
 
 
 
 
 
//Defiler un element de la tete de la Liste d'entiers
Liste defiler_l_int(Liste* l)
{
Liste p=*l, q=p->suiv;
if(p!=NULL){
            *l=q;
            p->suiv=NULL;
 
            }
return p;
free(p);
}
 
//afficher un tableau d'entiers
void afficher_tab(int t[])
{int i;
     for(i=0;i<9;i++)
            {
                if((i%3)==0)   { printf("\n[ %d ]",t[i]);}
 
                else {printf("[ %d ]",t[i]);}
             }
     }
 
//test l'egalite de deux tableaux d'entier
int egal_tab(int t1[],int t2[])
{int i;
int c=0;
     for(i=0;i<9;i++)
     {if(t1[i]!=t2[i]){c++;}}
     if(c==0) {return 1;}
     else {return 0;}
}
 
//permuatation de deux entiers
void permutation(int* a, int* b)
{
int t;
t=*a;
*a=*b;
*b=t;
}
 
//rechercher l'indice d'un entier dans un tableau
int rech_ind_ent(int t[9],int x)
{   int ind = 10;
	int i=0;
    for (i=0;i<9;i++){if (t[i]==x) ind=i;}
		return ind;
 
}
 
//tester les permutation possible de la case qui à l'indice comme parametre dans la fonction
Liste Test_permut(int g)
{
	Liste pp=NULL;
 
if((g<9)&&(g>-1))
{
switch (g)
{
	case 0:
	{
		emfiler_l_int(&pp,1);
		emfiler_l_int(&pp,3);
	break;}
 
	case 1:
	{
		emfiler_l_int(&pp,0);
		emfiler_l_int(&pp,2);
		emfiler_l_int(&pp,4);
	break;}
 
 
	case 2:
	{
		emfiler_l_int(&pp,1);
		emfiler_l_int(&pp,5);
	break;}
 
	case 3:
	{
		emfiler_l_int(&pp,0);
		emfiler_l_int(&pp,4);
		emfiler_l_int(&pp,6);
 
	break;}
 
	case 4:
	{
		emfiler_l_int(&pp,1);
		emfiler_l_int(&pp,3);
		emfiler_l_int(&pp,5);
		emfiler_l_int(&pp,7);
 
	break;}
 
	case 5:
	{
		emfiler_l_int(&pp,2);
		emfiler_l_int(&pp,4);
		emfiler_l_int(&pp,8);
 
	break;
	}
 
	case 6:
	{
	emfiler_l_int(&pp,3);
	emfiler_l_int(&pp,7);
	break;}
 
	case 7:
	{
	emfiler_l_int(&pp,4);
	emfiler_l_int(&pp,6);
	emfiler_l_int(&pp,8);
 
	break;}
 
	case 8:
	{
	emfiler_l_int(&pp,5);
	emfiler_l_int(&pp,7);
	break;}
	default:{};
}
}
return pp;
}
 
 
//*****************************************************************************
//structure Noeud Abr
typedef struct sNoeud {
  int grille[9];
  int niv;
  struct sNoeud* pr;
    struct sNoeud* suiv;
  struct sNoeud* s1;
  struct sNoeud* s2;
   struct sNoeud* s3;
   struct sNoeud* s4;
                    }Neoud;
typedef Neoud* Abr;
 
 
//creation d'un Noeud
Abr creation_Abr(int vval[])
{ Abr e  = malloc(sizeof(*e));
    e->pr=NULL;
    e->suiv=NULL;
    e->s1=NULL;
	e->s2=NULL;
	e->s3=NULL;
	e->s4=NULL;
    if(e!=NULL) {
                    int i;
                    for(i=0;i<9;i++){e->grille[i] = vval[i] ;}
 
                }
    return e ;
}
 
//Afficher un arbre
void affich_Abr(Abr r)
{
  if (r != NULL) {
                    printf("\n* * * * * * * * *");
                    afficher_tab(r->grille);
                }
 
if (r->s1 != NULL) {affich_Abr(r->s1);}
if (r->s2 != NULL) {affich_Abr(r->s2);}
if (r->s3 != NULL) {affich_Abr(r->s3);}
if (r->s4 != NULL) {affich_Abr(r->s4);}
 
}
 
//ENFILER UN Noeud DANS L'Abr
void emfiler_n_Abr(Abr* l,int vval[])
{   Abr  q = *l ;
Abr e  = creation_Abr(vval);
    if(q==NULL) {e->pr=NULL;
                *l =e;
 
                }
    else {
            while(q->suiv!=NULL) {q = q->suiv ;}
            q->suiv = e ;
            e->pr=q;
        }
}
 
//ENPILER UN Noeud DANS l'Abr
void empiler_n_Abr(Abr* l,Abr e)
{   Abr  q = *l ;
 
    if(q==NULL) {
 
                *l =e;}
 
 
    else {
            e->suiv = q ;
            q->pr=e;
            e->pr = NULL ;
            *l =e;
 
        }
}
 
//DEFILER UN Noeud DANS L'Abr
Abr defiler_n_Abr(Abr* l)
{
Abr p=*l;
if(p!=NULL){
 
            return p;
            }
 
 
}
 
//DEPILER UN Noeud DANS L'Abr
Abr depiler_n_Abr(Abr* l)
{
Abr p=*l, q=p->suiv;
if(p!=NULL){
            *l=q;
            p->suiv=NULL;
 
            }
return p;
 
}
//Creer les Successeurs dun Noeud
void successeur(Abr* r)
{
Abr q=*r;
 
if(q!=NULL){
 
 Liste pp=Test_permut(rech_ind_ent(q->grille,0));
 
 if(pp!=NULL)
    {
 
            q->s1=creation_Abr(q->grille);
            q->s1->niv=q->niv+1;
            q->s1->pr=q;
            permutation(&q->s1->grille[rech_ind_ent(q->s1->grille,0)],&q->s1->grille[pp->val]);
			if(pp->suiv!=NULL)
				{
 
					q->s2=creation_Abr(q->grille);
					q->s2->niv=q->niv+1;
					q->s2->pr=q;
					permutation(&q->s2->grille[rech_ind_ent(q->s2->grille,0)],&q->s2->grille[pp->suiv->val]);
						if(pp->suiv->suiv!=NULL)
							{
 
								q->s3=creation_Abr(q->grille);
								q->s3->niv=q->niv+1;
								q->s3->pr=q;
								permutation(&q->s3->grille[rech_ind_ent(q->s3->grille,0)],&q->s3->grille[pp->suiv->suiv->val]);
									if(pp->suiv->suiv->suiv!=NULL)
										{
 
											q->s4=creation_Abr(q->grille);
											q->s4->niv=q->niv+1;
											q->s4->pr=q;
											permutation(&q->s4->grille[rech_ind_ent(q->s4->grille,0)],&q->s4->grille[pp->suiv->suiv->suiv->val]);
										}
							}
				}
 
    }
 
		}
 
}
 
 
 
 
 
 
 
 
 
/*PROGRAMME PRINCIPAL*/
int main()
{
Abr fron=NULL;
Abr sol=NULL;
 
 
Abr n=creation_Abr(start);
Abr n1=creation_Abr(start);
successeur(&n1);
 
emfiler_n_Abr(&fron,n->grille);
 
Abr test=fron;
int bosol=0;
while((test!=NULL)&&(bosol==0)){
 
    if(egal_tab(test->grille,goal)){Abr p=test;
                                        p->suiv=NULL;
                                        while(p!=NULL){
                                                        empiler_n_Abr(&sol,p);
 
                                                        p=p->pr;
                                                        }
 
                                    bosol=1;}
    else{
 
        successeur(&test);
        if(test->s1!=NULL) {emfiler_n_Abr(&fron,test->s1->grille);}
        if(test->s2!=NULL) {emfiler_n_Abr(&fron,test->s2->grille);}
        if(test->s3!=NULL) {emfiler_n_Abr(&fron,test->s3->grille);}
        if(test->s4!=NULL) {emfiler_n_Abr(&fron,test->s4->grille);}
        }
test=test->suiv;
}
 
 
 
Abr sq=sol;
int com=0;
if(sq!=NULL){printf("la pile Sol  NOT NULL");}
while(sq!=NULL){
                printf("\n\n*****( %d )*****",++com);
                afficher_tab(sq->grille);
                sq=sq->suiv;
                }
 
}

en exécutant ce code voila le résultat

Ce résultat n'est pas correcte mais je comprends pas ou est le problème !

Aidez moi svp

Un Tableau de Structure en C ?

C

Discussions similaires

Partager

Partager