Árvore binária, implementação defeituosa

Gente, tou tentando expandir um pouco a idéia de árvore binária em C.

Estou tentando criar uma árvore mais complexa na qual cada nó é ligado a quantos nós filhos a memória permite. Cada nó possui quantos atributos forem possíveis.

Comecei a produzir o código hoje, mas como sou novo nisso de programar em C, não consegui dar os primeiros passos corretamente, pelo menos é o que diz o compilador. Vejam o esboço de código:


/*
============================================================================
Name : MenuArvore.c
Author : Arthur Farias
Version : 0.1
Copyright : Your copyright notice
Description : Hello World in C, Ansi-style
============================================================================
*/
#include <stdio.h>
#include <stdlib.h>

typedef struct {
int child_count;
Attribute * attribute;
Node * child;
} Node;

typedef struct {
char *label;
char *content;
} Attribute;

int main(void) {
return EXIT_SUCCESS;
}

// Node Operations

int append_child(Node *parent) {

Node child;
child.child_count = 0;

parent.child = (Node*) realloc (parent.child, (parent.child_count+1)*sizeof(Node));

if (parent.child != NULL) {
parent.child[parent.child_count] = child;
return EXIT_SUCCESS;
}

return !EXIT_SUCCESS;

}

int remove_child(Node *node, int child_position) {

int i;

for (i = node.child_position; i <= node.child_count; i++) {
node.child[node.child_position] = node.child[node.child_position+1];
}
parent.child = (Node*) realloc (parent.child, (parent.child_count)*sizeof(Node));

return EXIT_SUCCESS;
}

int set_attribute() { // (num_params, params (node_id, title, content))
return EXIT_SUCCESS;
}

int remove_attribute() {
return EXIT_SUCCESS;
}

Então não seria uma árvore Binária, pois nesta só tem dois nós filho

Verdade, foge a definição...

mesmo assim, o referido código não funciona, alguém sabe como alocar memória para o membro de uma struct dinamicamente? ou é impossível?

Se não tá compilando manda a saida do compilador pra gente ver onde está o erro.

Tem muita coisa errada olha o novo código e a saída do compilador


/*
============================================================================
Name : MenuArvore.c
Author :
Version :
Copyright : Your copyright notice
Description : Hello World in
C, Ansi-style
============================================================================
*/
#include <stdio.h>
#include <stdlib.h>

typedef struct Node_t{
int nChilds;
int nAttributes;
struct Attribute *attribute;
struct Node **child;
} Node;

typedef struct Attribute_t{
char *label;
char *content;
} Attribute;



// Node Operations

int append_child(Node *node, struct Node * child) {

Node nodeBackup = *node;

if (node->nChilds == 0) {
if ((node->child = (Node **) calloc (1, sizeof(Node **))) == NULL) {
*node = nodeBackup;
exit(1);
} else {
node->nChilds = 1;
node->child[0] = child;
}
} else {
if ((node->child = (Node **) realloc(node, (node->nChilds+1)*sizeof(Node **))) == NULL) {
*node = nodeBackup;
exit(1);
} else {
node->nChilds++;
node->child[node->nChilds-1] = child;
}
}

exit(0);

}

int remove_child(Node *node, int child_position) {
int i;
if (node->nChilds == 0) {
exit (1);
} else {
for (i = 0; i < node->nChilds-child_position; i++) {
node->child[child_position-1] = node->child[child_position];
node->child = (Node **) realloc(node, node->nChilds-1 * sizeof(Node **));
}
}
return EXIT_SUCCESS;
}

int set_attribute() { // (num_params, params (node_id, title, content))
return EXIT_SUCCESS;
}

int remove_attribute() {
return EXIT_SUCCESS;
}

int main(void) {

Node root;
Attribute attr;

attr.label = "teste";
root.nChilds = 1;

root.attribute[0] = attr;

printf("%s", root.attribute.label);

//printf("%s", append_child(root, child));

return EXIT_SUCCESS;
}


==================================================

**** Build of configuration Debug for project MenuArvore ****

**** Internal Builder is used for build ****
gcc -O0 -g3 -Wall -c -fmessage-length=0 -osrc\MenuArvore.o ..\src\MenuArvore.c
..\src\MenuArvore.c: In function `append_child':
..\src\MenuArvore.c:35: warning: assignment from incompatible pointer type
..\src\MenuArvore.c:43: warning: assignment from incompatible pointer type
..\src\MenuArvore.c: In function `remove_child':
..\src\MenuArvore.c:63: warning: assignment from incompatible pointer type
..\src\MenuArvore.c: In function `main':
..\src\MenuArvore.c:85: error: invalid use of undefined type `struct Attribute'
..\src\MenuArvore.c:85: error: dereferencing pointer to incomplete type
..\src\MenuArvore.c:87: error: request for member `label' in something not a structure or union
Build error occurred, build is stopped
Time consumed: 504 ms.

Gente, agora o código não tem mais defeito, aparente. Consigo adicionar nós e atributos ao root, porém quando tento pendurar um atributo a um nó dentro de root dá um erro em tempo de execução!

O interessante é quando penduro um atributo em root não ocorre nenhum erro! Vejam, compilem o código!

Só uma curiosidade, vocês conseguem ver algum tipo de utilidade para este código como eu consigo?

Novo Código:

/*
============================================================================
Name : MenuArvore.c
Author :
Version :
Copyright : Your copyright notice
Description : Hello World in
C, Ansi-style
============================================================================
*/
#include <stdio.h>
#include <stdlib.h>

typedef struct Attribute_t{
char *label;
char *content;
} Attribute;

typedef struct Node_t{
int nChilds;
int nAttributes;
Attribute **attribute;
struct Node_t **child;
} Node;

// Node Operations

int append_child(Node *, Node *);
int remove_child(Node *, int);
int append_attribute(Node *, Attribute *);
int remove_attribute(Node *, int);
int set_attribute(Node *, char *, char *);
char *get_attribute(Node *, char *);

int main(void) {

Node root, child1;
Attribute attr1;

attr1.label = "etiqueta";
attr1.content = "conteudo";

root.nChilds = 0;
root.nAttributes = 0;

append_child(&root, &child1);

append_attribute (root.child[0], &attr1);
printf("%s %s\n", root.child[0]->attribute[0]->label, root.child[0]->attribute[0]->content);


//printf("%s", append_child(root, child));

return EXIT_SUCCESS;
}

int append_child(Node *node, Node * child) {

if (node->nChilds == 0) {
if ((node->child = (Node **) calloc (1, sizeof(Node *))) == NULL) {
return -1;
} else {
node->nChilds = 1;
node->child[0] = child;

}
} else {
if ((node->child = (Node **) realloc(node->child, (node->nChilds+1)*sizeof(Node *))) == NULL) {
return -1;
} else {
node->nChilds++;
node->child[node->nChilds-1] = child;
}
}

return 0;

}

int remove_child(Node *node, int child_position) {
int i;
if (node->nChilds == 0) {
return -1;
} else {
for (i = 0; i < node->nChilds-child_position; i++) {
node->nChilds--;
node->child[child_position-1] = node->child[child_position];
node->child = (Node **) realloc(node, node->nChilds * sizeof(Node *));
}
}
return 0;
}

int append_attribute(Node * node, Attribute * attr) {

if (node->nAttributes == 0) {
if ((node->attribute = (Attribute **) calloc (1, sizeof (Attribute *))) == NULL) {
return -1;
}
else {
node->nAttributes = 1;
node->attribute[0] = attr;
}
} else {
if ((node->attribute = (Attribute **) realloc (node->attribute, sizeof (Attribute *))) == NULL) {
return -1;
} else {
node->attribute[node->nAttributes] = attr;
node->nAttributes++;
}
}

return 0;
}

int remove_attribute(Node *node, int attribute_position) {
int i;
if (node->nAttributes == 0) {
return -1;
} else {
for (i = 0; i < node->nAttributes-attribute_position; i++) {
node->nAttributes--;
node->attribute[attribute_position-1] = node->attribute[attribute_position];
node->attribute = (Attribute **) realloc(node, node->nAttributes * sizeof(Attribute *));
}
}
return 0;
}

int set_attribute(Node * node, char * label, char * content) {

int i;
for (i=0; i<node->nAttributes && node->attribute[i]->label != label; i++);

node->attribute[i]->label = label;
node->attribute[i]->content = content;

return 0;
}

char *get_attribute(Node * node, char * label) {

int i;
for (i=0; i<node->nAttributes && node->attribute[i]->label != label; i++);

if (i == node->nAttributes) {
return NULL;
} else {
return node->attribute[i]->content;
}

return 0;
}

Opa, o problema era só colocar a forma correta na função e zerar os contadores de nó.
Alguém sabe alguma maneira de contar a quantidade de nós de forma que eu não precise colocar a quantidade inicial sempre que eu precise iniciar um novo nó?

Eu tentei fazer em append_child uma contagem indexada e não deu certo, a primeira ocorrência de um null é lá pro indice 32930129....

abraço e muito obrigado desde já pela colaboração da comunidade!

Nao consigo pensar em nada alem de mapear a arvore de processos....
Qual outra utilidade você viu pra isso?