Discussion :

[Invité]

J'ai un problème pour récupérer un entier qui est paramètre d'une fonction récursive. Cette fonction me renvoie une liste chainée et la valeur de l'entier doit être modifiée à chaque appel de fonction et me sert dans des boucles de la fonction; c'est pour ça que j'utilise un pointeur sur cet entier. Mon problème est que le programme me renvoie dans ma liste chainée un entier qui n'a rien à voir (-81265478 ou quelque chose du genre au lieu de 0 ou 1). En fait, j'ai un truc du genre :

dans la fonction "main", j'ai :

Code :

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

1
2
3
4
5
6
7
int n=N;       N=constante dans DEFINE
int val={0,1};         val=tableau de base
int max=2;             max=indice courant maximum de val
...
while(....){
      ch=chainer(n, &max,val);
}

et dans la fonction "chainer", j'ai:

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
chaine chainer(int n, int *max, val[]){
      chaine *deb=malloc(sizeof(chaine));
      ....
      if(...){
            chainer(n-1,max);
      }
      else{
            ....
            for(i=o,i<max;i++){
                deb->tab[i]=val[max];
                ...
            }
            max=max-1;
      }
      return *deb;
}

[souviron34]

Code :

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

1
2
3
4
5
6
            for(i=o,i<*max;i++){
                deb->tab[i]=val[*max];
                ...
            }
            *max=*max-1;

[darrylsite]

Un code complet nous permettra de mieux voir ce qui ne va pas.

[Invité]

Je ne voulais pas mettre trop de lignes de code pour pas que ça soit illisible et ne diminue mes chances d'avoir une réponse.

[Invité]

Voici mon code complet. J'espère qu'il n'est pas trop long. Avec N=1, ça déconne (comme expliqué dans mon premier message) et avec N>1, ça plante.

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

[Invité]

En fait, il s'agit d'un tableau de listes doublement chainées. Chaque élément de la liste contient un tableau. Pour que le travail à faire par le programme soit plus clair, je vais donner un exemple (c'est un problème mathématique) après une courte présentation. L'espace est une combinaison de plusieurs vecteurs de taille 2 dont les valeurs possibles sont 0 ou 1. Le nombre de vecteur est N. Le but étant de trouver un nombre minimum d'antichaine pour représenter l'espace. Une antichaine se compose de combinaisons des vecteurs de départ. Chaque antichaine est représentée par une liste doublement chainée et l'ensemble de l'espace sera le tableau qui contiendra les listes doublement chainées.

Exemple: si N=2, il existe 2 antichaines (nb_ch dans le code) qui seront
* 00-01-11
* 10

si N=3, il existe 3 antichaines qui seront
* 000-001-011-111
* 010-110
* 100-101

si N=4, il existe 6 antichaines

si N=5, il existe 10 antichaines, puis ça augmente de plus en plus avec N (mais ça ne peut pas être multiplier par plus que 2 quand on passe de N à N+1)