Discussion :

[BlackStitch]

Bonjour,

Le but de cet fonction et de parcourir une matrice jusqu'à trouver un 1, si on trouve 1 on inspecte ces alentours (via une matrice de connexion déclarer plus loin dans mon code) .

Je rencontre un problème avec ma fonction, lors du premier passage tous ce passe bien, j'initialise mon pointeur courant, et le remplit, mon pointeur courant contient bien ce qu'il doit contenir,j'inspecte les alentours, et remplit un tableau de fils en fonction des 1 présent dans les alentours, (N,NE,E,SE,S,SO,O,NO). Pour finir je rappel ma fonction pour inspecter les environs du premier fils puis du deuxième etc ...

Mais lorsque je rappel ma fonction pour la première fois, mon noeud courant qui contient normalement des coordonnées etc ... ne contient rien, j'ai trouver un moyen de faire fonctionne cette fonction en déclarant 4 fils dans ma structure noeud, au lieu de déclarer un tableau de fils, mais le code dans la fonction devient horrible et redondant, mais il fonctionne ... j'aimerais donc comprendre ou et le problème lorsque j'utilise un tableau :/ ...

En espérant avoir été clair.

Code :

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

1
2
3
4
5
6
7
8
typedef struct noeud noeud; /// structure de l'arbre
struct noeud
{
	int x;
	int y;
	int longue_chaine;
	struct noeud **fils[4]; // Problème peut être ici ?
};

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
noeud *creation_noeud(int x, int y)
{
	noeud * N = malloc(sizeof(noeud));
	N->x = x;
	N->y = y;
	N->longue_chaine = 0;
	int f = 0;
	for (f = 0; f < 4; f++) // On initialise les fils a 0;
	{	
		N->fils[f] = malloc(sizeof(noeud));
		N->fils[f] = NULL;
	}
};

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
void construire_arbre_un_motif(noeud ** arbre, int tab[8][8], CX mat_CX[8]) /// construit UN ET UN SEUL arbre, suivant UN ET UN SEUL motif
{
	noeud * courant = *arbre; // Bug ici il n'y  a rien au deuxième passage! 
	if (!courant) // premier appel: l'arbre est vide, on l'initialise...
	{
		int i = 0, j = 0;
 
		while (tab[i][j] == 0) //... on cherche la premiere valeur non nulle ( = point de départ du motif )
		{
			j++;
			if (j == 8)
			{
				i++;
				j = 0;
			}
		}
		courant = creation_noeud(i, j);
		tab[i][j] = 0; // et on indique que la premiére case a été traitée
	}
 
	int i;
	int x = courant->x; // Sa crash ICIIIIIIIIIIIIIIIIII
	int y = courant->y; // on récupére les coordonnées stockées dans l'arbre, pour faciliter les calculs.
 
 
	int Indice;
 
	for (i = 0; i <= 7; i++)  // On cherche la première cardinalité, dans la matrice de connexion
	{
		if (mat_CX[i].ordre == 1)
		{
			Indice = i;
		}
 
	}
	int z = 0;
	int k = 0;
	int memA=0;
	int memB=0;
	for (k = 0; k < 8; k++)
	{
		memA = x + mat_CX[Indice].coordx;
		memB = y + mat_CX[Indice].coordy;
 
		if ((tab[memA][memB] == 1) && (memA>=0 && memB>=0 && memA< 8 && memB< 8))
		{
			tab[x][y] = 0;
			/*tab_c[k]->x = memA;
			tab_c[k]->y = memB;*/
 
			courant->fils[z] = creation_noeud(memA,memB); // // Problème peut être ici ?
			z++;
 
		}
		Indice = (Indice + 1) % 8;
	}
 
 
	int w = 0;
	for (w = 0; w < 4; w++);
	{
		if (courant->fils[w])
		{construire_arbre_un_motif(&(courant->fils[w]), tab, mat_CX);  // Problème peut être ici ?
		}
	}
*arbre = courant; // On sauve pour finir l'arbre dans la variable passée en paramétres}

[Sve@r]

Code :

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

1
2
3
4
5
6
7
8
typedef struct noeud noeud; /// structure de l'arbre
struct noeud
{
	int x;
	int y;
	int longue_chaine;
	struct noeud **fils[4]; // Problème peut être ici ?
};

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
noeud *creation_noeud(int x, int y)
{
	noeud * N = malloc(sizeof(noeud));
	N->x = x;
	N->y = y;
	N->longue_chaine = 0;
	int f = 0;
	for (f = 0; f < 4; f++) // On initialise les fils a 0;
	{	
		N->fils[f] = malloc(sizeof(noeud));
		N->fils[f] = NULL;
	}
};

Bonjour

Je vois (au-moins) deux problèmes

1. si ton noeud a 4 fils, alors tu dois lui déclarer un tableau de 4 "struct noeud*" et non 4 "struct noeud **" puisque tu dois stocker 4 pointeurs pointant chacun vers un noeud. Si maintenant il a "n" fils (n inconnu), alors tu dois déclarer un struct noeud **fils puis quand "n" sera connu alors écrire ensuite fils=malloc(n * sizeof(noeud *)) puis ensuite seulement tu pourras remplir fils[f] avec l'adresse des autres noeuds. Mais en tout cas pas mélanger les deux cas avec ton struct noeud **fils[4]...
2. ta fonction de creation de noeud ne doit pas faire de malloc pour les fils puisque un fils étant à la base un autre noeud, celui-ci aura été déjà alloué lors de sa création. Surtout qu'en plus tu écris fils[f]=malloc... puis juste en dessous fils[f]=NULL. Rien que ça déjà (remplir deux fois la même variable sans l'avoir traitée) ça aurait dû te sauter aux yeux. Quoi qu'il en soit, ici c'est fuite mémoire assurée.

[BlackStitch]

Je te remercie pour tes conseils ils mon été utile ! j'ai réanalyser mon problème, et j'ai préféré créer un arbre binaire, ce qui simplifie mon problème, néanmoins mes arbres sont stockée dans un tableau de structure noeud, et tes conseils mon permis de terminer mon projet x), voila merci