Bonjour.

J'ai un problème avec mon programme, il plante tout le temps. Je vous ai mis le code ci-dessous. Le problème se situe dans la fonction "chainer" qui doit renvoyer une liste doublement chainée à la fonction main et à elle-même car il s'agit d'une fonction récursive. Quand le paramètre N vaut 1, la fonction ne s'appelle pas elle-même et il n'y a pas de problème. Par contre, quand N>1, le fonction "chainer" s'appelle elle-même et ça plante. Le débogage indique que le plantage a lieu à la ligne 85, c'est-à-dire quand la fonction s'appelle elle-même. En fait, la liste chainée "debinf" en question est un paramètre de la fonction, elle doit être unique, les modifications doivent se répercuter à chaque appel récursif de la fonction "chainé" et la liste chainée "debinf" doit être conservée pour construire les listes chainées suivantes à partir de la fonction main où se trouve une boucle qui se charge de cela, c'est pourquoi j'ai utilisé un pointeur pour "debinf" afin que sa valeur soit conservée lors de chaque itération dans le main.

Pouvez-vous m'aider SVP? Merci d'avance.

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
 
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<string.h>
#include<math.h>
 
const int N=2;
 
typedef struct antichaine{
	int tab[N];
	struct antichaine *prec;
	struct antichaine *suiv;
}chaine;
 
double fact(int n);
//void liberation(chaine *parcours);
chaine chainer(int n, int c, int val[], int *max, chaine *debinf);
void affichage(chaine *ch, int n, int nb_ch);
 
 
void main(){
	int n=N;
	int taille_esp=(int)pow((double)2,(double)n);
	int m=(int)n/2;
	int nb_ch=fact(n)/(fact(n-m)*fact(m)); //nombre de chaînes
	n=N;
	//int **esp=(int**)calloc(taille_esp,sizeof(int));	
	int val[2]={0,1};
	int i=0, j=0, k=0, c=n, max=2;
 
	chaine *ch=(chaine*)calloc(nb_ch,sizeof(struct antichaine));
 
	chaine *debinf=(chaine*)calloc(1,sizeof(struct antichaine));
	debinf=NULL;
 
	for(i=0;i<nb_ch;i++){
 
 
		ch[i]=chainer(n,c,val,&max,debinf);
		ch[i]=*ch[i].suiv;
		ch[i].prec=NULL;
		free(ch[i].prec);
		affichage(&ch[i],n,nb_ch);
		//printf("%d\n",debinf->tab[0]);
	}
 
}
 
double fact(int n){
	if(n<0){
      exit (EXIT_FAILURE);
	}
	else if(n==1 || n==0){
		return 1;
	}return n*fact(n-1);
}
 
 
 
void liberation(chaine *parcours){
	while((parcours->suiv)!=NULL){
		parcours=parcours->suiv;
		free(parcours->prec->tab);
	}
	free(parcours->tab);
	free(parcours);
}
 
chaine chainer (int n,int c, int val[], int *max, chaine *debinf){
	int k,l;
	//chaine *deb=(chaine*)malloc(sizeof(struct antichaine));
	chaine *parcours=(chaine*)malloc(sizeof(struct antichaine));
	//chaine *parcoursinf;
	chaine *tmp;
	chaine *suppr;
	//deb->prec=NULL;
	//deb->suiv=NULL;
	//parcours=deb;
	parcours->prec=NULL;
	parcours->suiv=NULL;
 
	if(debinf==NULL || (*max)<0){	
		(*max)=2;
		if(n>1){
			debinf=chainer(n-1,c,val,max,debinf);
		}
		else if(n==1){
			for(k=0;k<(*max);k++){
				tmp=(chaine*)malloc(sizeof(struct antichaine));
				tmp->prec=NULL;
				tmp->suiv=NULL;
				tmp->tab[n-1]=val[k];
				parcours->suiv=tmp;
				tmp->prec=parcours;
				tmp->suiv=NULL;
				parcours=parcours->suiv;
			}
			while(parcours->prec!=NULL){
				parcours=parcours->prec;
			}
			return *parcours;
		}
		else if(n==0){
			exit (EXIT_FAILURE);
		}
	}
	if(debinf!=NULL){
		//liberation(parcours);
		chaine *parcours=(chaine*)malloc(sizeof(struct antichaine));
		parcours->prec=NULL;
		parcours->suiv=NULL;
		//parcoursinf=debinf;
		for(k=0;k<(*max);k++){
			tmp=(chaine*)malloc(sizeof(struct antichaine));
			tmp->prec=NULL;
			tmp->suiv=NULL;
			for(l=0;l<n-1;l++){
				tmp->tab[l]=debinf->tab[l];
			}
			tmp->tab[n-1]=val[k];
			parcours->suiv=tmp;
			tmp->prec=parcours;
			tmp->suiv=NULL;
			parcours=parcours->suiv;
		}
		debinf=debinf->suiv;
 
		while(debinf!=NULL){
			tmp=(chaine*)malloc(sizeof(struct antichaine));
			tmp->prec=NULL;
			tmp->suiv=NULL;
			for(l=0;l<n-1;l++){
				tmp->tab[l]=debinf->tab[l];
			}
			tmp->tab[n-1]=val[(*max)];
			parcours->suiv=tmp;
			tmp->prec=parcours;
			tmp->suiv=NULL;
			parcours=parcours->suiv;
			debinf=debinf->suiv;
		}
		while(debinf->prec!=NULL){
			debinf=debinf->prec;
		}
		suppr=debinf;
		debinf=debinf->suiv;
		debinf->prec=NULL;
		free(suppr);
 
		(*max)=(*max)-1;
	}
	while(parcours->prec!=NULL){
		parcours=parcours->prec;
	}
	//free(deb);
	//free(parcours);
	free(tmp);
	return *parcours;
 
}
 
void affichage(chaine *ch, int n, int nb_ch){
	int j;
 
	while(ch!=NULL){
		for(j=0;j<n;j++){
			printf("%d",ch->tab[j]);
		}
		ch=ch->suiv;
		printf(" ");
	}
	printf("\n");
 
}