Discussion :

[kimikimi]

Bonsoir,

Je suis en train de m'entrainer sur les AST , j ai reussi a faire une fonction qui cree
l'arbre puis initialise fils_g et fils_d
cependant je ne comprend pas comment chainee le tout , en creant un noeud dans un noeud .
Par ailleurs, est t-il possible d'avoir plusieurs structures ce chainant qui sont relies par "racine" , par exemple :

struct_tree --> struct_tree ---> Null
--> fils_g -->fils_g -> Null
--> fils_d -->fils_d --> 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
 
 
typedef struct s_tree	t_tree;
struct s_tree
{
  char	*cmd;
  struct s_tree	*fg;
  struct s_tree	*fd;
};
 
t_tree		*Add_Node(t_tree *tree_t, char *fg, char *fd)
{
  tree_t->fg = malloc(sizeof(*tree_t->fg) * strlen(fg));
  tree_t->fd = malloc(sizeof(*tree_t->fd) * strlen(fd));
 
  if (tree_t->fg != NULL && tree_t->fd != NULL)
    {
      tree_t->fg = fg;
      tree_t->fd = fd;
      return (tree_t);
    }
  return (NULL);
}
 
t_tree		*create_tree(t_tree *tree_t, char *cmd)
{
  t_tree	*new_t;
 
  new_t = malloc(sizeof(*new_t));
  if (new_t != NULL)
    {
      new_t->cmd = cmd;
      new_t->fg = NULL;
      new_t->fd = NULL;
      return (new_t);
    }
  return (NULL);
}

En esperant avoir ete clair ,
Cordialement

[Médinoc]

J'ai du mal à comprendre la question, mais les malloc() de Add_Node() sont complètement fantaisistes.

[Trademark]

En faisant un peu de renommage, on s'y retrouve un peu plus (exemple : t_tree -> node_t ; char* fd -> char* cmd_fd). Et puis comme l'a dit Médinoc tes malloc sont mauvais.

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
 
node_t* Add_Node(node_t *pere, char *cmd_fg, char *cmd_fd)
{
  pere->fg = malloc(sizeof(node_t)) ;
  pere->fd = malloc(sizeof(node_t)) ;
 
  if (pere->fg != NULL && pere->fd != NULL)
    {
      pere->fg->cmd = malloc(sizeof(char) * strlen(cmd_fg));
      pere->fd->cmd = malloc(sizeof(char) * strlen(cmd_fd));
      pere->fd->fd = NULL ;
      pere->fd->fg = NULL ;
      pere->fg->fg = NULL ;
      pere->fg->fd = NULL ;
 
 
      strncpy (pere->fg->cmd , cmd_fg, strlen(cmd_fg) ) ;
      strncpy (pere->fd->cmd , cmd_fd, strlen(cmd_fd) ) ;
      return pere ;
    }
  return NULL ;
}

Il faut que tu alloues les deux fils du père (2 premier malloc) mais également les chaines de caractères de ces deux fils (2 suivant).
Pour mieux découper ton programme tu pourrais ajouter une fonction "init_node(node_t* node, char* cmd)".
Tu pourrais également ajouter des vérifications pour voir si les fils de ton noeud ne sont pas déjà initialisés.

N'oublie pas de NULL-terminé tes chaines de caractères (finir par '\0').
Et pour finir, garde en tête que ton return n'est là que pour de l'ergonomie.

[kimikimi]

Je vous remercie pour vos reponses, je vais re-travailler un peu mon code ,
merci pour vos indications ,
Cordialement

[kimikimi]

Bonjour,

Apres quelques essai , j arrive a initialiser correctement mon premier arbre,
Maintenant je souhaite savoir comment faire pour descendre en profondeur.
Je Segfault lorsque je tente de cree un sous arbre en recursif dans la fonction create_arbre() ,
Merci de bien vouloir m eclairer ..
Cordialement

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
 
t_tree	*fils_droit(t_tree *racine, char *droite)
{
  racine->droite = malloc(sizeof(*racine->droite) * strlen(droite));
  if (racine->droite != NULL)
    {
      racine->droite = droite;
      return (racine->droite);
    }
  return (NULL);
}
 
t_tree	*fils_gauche(t_tree *racine, char *gauche)
{
  racine->gauche = malloc(sizeof(*racine->gauche) * strlen(gauche));
  if (racine->gauche != NULL)
    {
      racine->gauche = gauche;
      return (racine->gauche);
    }
  return (NULL);
}
 
t_tree		*creation_arbre(t_tree *racine, char *mot, char *gauche, char *droit)
{
  if (racine == NULL)
    {
      racine = allocate_tree();
      racine->cmd = dupchaine(mot);
 
      racine->gauche = fils_gauche(racine, gauche);
      racine->droite = fils_droit(racine, droit);
    }
  else if (racine != NULL) 
    {
      if (racine->gauche == NULL)
	racine->gauche = creation_arbre(racine->gauche, mot, gauche, droit);
 
      else
	racine->droite = creation_arbre(racine->droite, mot, gauche, droit);
    }
  return (racine);

[Médinoc]

1.
Déjà, ta création d'arbre, elle est censée faire quoi? Parser une ligne de commande (ou une fonction mathématique) pour en faire un arbre?
Ou elle est censée être appelée par la fonction qui fait ça?

2.
Tes mallocs sont toujours confus. Essaie de mieux décomposer ton 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
char * mystrdup(char const *input)
{
	if(input == NULL)
		return NULL;
	else
	{
		char * ret = malloc(strlen(input) + 1);
		if(ret != NULL)
			strcpy(ret, input);
		return ret;
	}
}
 
t_tree * CreerNoeud(char const *cmd)
{
	t_tree * pNoeud = malloc( sizeof *pNoeud );
	if(pNoeud != NULL)
	{
		pNoeud->cmd = mystrdup(cmd);
		pNoeud->fg = NULL;
		pNoeud->fd = NULL;
	}
}

Ainsi, tes fonctions ressembleront plus à cela:

Code :

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

1
2
3
4
5
t_tree * AjouterFilsDroit(t_tree * racine, char const *cmd)
{
	racine->fd = CreerNoeud(cmd);
	return racine->fd;
}