Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
il programma non viene compilato segnalando diversi warning sull' incopatibilità dei dati ( i cui motivi non so spiegarmeli, in quanto teoria , non vi sono incoerenze), e un problema di referenziazione di una funzione.
di seguito trovate l' output prodotto da minGW
Codice sorgente - presumibilmente Delphi
C:\test>gcc main.c
main.c:Infunction'main':
main.c:50:1: warning: passing argument 2 of'costruiscialbero' makes pointer fro
Se può tornarti utile qualche mese fa ho dovuto scrivere un ADT per gestire un bst. Penso sia interessante perché in questo esempio viene memorizzato tutto dinamicamente. Risulta più complicato in certi punti mentre in altri, invece, risulta più pratica la gestione della struttura dati. Ti riporto qualche pezzo di codice:
bst.h
Codice sorgente - presumibilmente C++
#include "item.h"
typedefstruct t_bst *BST;
BST bst_init();
void bst_insert_leaf(BST bst, Item i);
int bst_tree_height(BST bst);
void bst_destroy(BST bst);
bst.c
Codice sorgente - presumibilmente C++
#include <stdlib.h>
#include <stdio.h>
#include "item.h"
#include "bst.h"
typedefstruct bst_node *link;
struct bst_node{
Item item;//node item
link left;//left child
link right;//right child
int n;//size of sub-tree
};
struct t_bst{
link root;
};
BST bst_init()
{
BST bst =malloc(sizeof(*bst));
bst->root =NULL;
return bst;
}
link new_node(Item i, link l, link r, int n)
{
link new=malloc(sizeof(*new));
new->item = i;
new->left = l;
new->right = r;
new->n = n;
returnnew;
}
void bst_insert_leaf(BST bst, Item i)
{
//if empty bst
if(bst->root ==NULL)
{
bst->root = new_node(i, NULL, NULL, 1);
return;
}
//if not empty bst
link p = bst->root;//father
link x = p;//actual pointer
while(x !=NULL)
{
p = x;
x->n++;
if(item_compare(i, x->item)< 0)
x = x->left;
else
x = x->right;
}
x = new_node(i, NULL, NULL, 1);
if(item_compare(i, p->item)< 0)
p->left = x;
else
p->right = x;
}
void pre_order(link p, FILE*fp)
{
item_print(p->item, fp);
if(p->left !=NULL)
pre_order(p->left, fp);
if(p->right !=NULL)
pre_order(p->right, fp);
}
void in_order(link p, FILE*fp)
{
if(p->left !=NULL)
in_order(p->left, fp);
item_print(p->item, fp);
if(p->right !=NULL)
in_order(p->right, fp);
}
void post_order(link p, FILE*fp)
{
if(p->left !=NULL)
post_order(p->left, fp);
if(p->right !=NULL)
post_order(p->right, fp);
item_print(p->item, fp);
}
void destroy(link p)
{
if(p->left !=NULL)
destroy(p->left);
if(p->right !=NULL)
destroy(p->right);
item_free(p->item);
}
void bst_destroy(BST bst)
{
if(bst->root !=NULL)
destroy(bst->root);
free(bst);
}
Se ti serve anche qualche altro pezzo di codice, come ad esempio l'inserimento in radice, dimmelo che te lo spedisco volentieri.
Come puoi vedere le visite in pre/in/post order sono molto chiare grazie a questa tipo di struttura dati, mentre e` più rognosa la parte di deallocazione e di inserimento.
Grazie mille, ho optato per gli array perché purtroppo, per quanto più elegante fosse la soluzione con le struct , purtroppo in sede di esame, ho poco tempo per scrivere il programma.
Con gli array sembra funzionare tutto molto bene , appena avrò del tempo proverò sicuramente ad implementare la tua soluzione XBarboX