Newsgroup: it.comp.lang.c
Titolo: Aiuto per albero binario

Salve a tutti, premetto che ho poca dimestichezza con il linguaggio c
Ho un problema con un albero binario.
Come faccio a scrivere il percorso dalla radice ad ogni foglia
dell'albero?
Cioe' per ogni foglia devo dire quale percorso ho fatto dalla radice
per raggiungerla.
F.

 per raggiungerla.
Scritto al volo, dovrebbe andare:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
typedef struct tag_node {
   int d;
   struct tag_node *sx, *dx;   
} node_t, *pnode_t;
pnode_t node_new(int d)
{
    pnode_t self=malloc(sizeof *self);
    if (self) {
       self->d=d;
       self->sx=0;
       self->dx=0;       
    }    
}
void node_fee(pnode_t self)
{
     if (self)
        free(self);       
}
typedef struct {
   pnode_t root;
} bintree_t, *pbintree_t;
pbintree_t bintree_new(void)
{
     pbintree_t self=malloc(sizeof *self);
     if (self) {
        self->root=0;       
     }
     return self;
}
static void bintree_insert_node(pnode_t* p, int d)
{
    if (!*p)
      *p=node_new(d);
    else 
    if (d<(*p)->d) 
      bintree_insert_node(&(*p)->sx, d);
    else 
    if (d>(*p)->d)
      bintree_insert_node(&(*p)->dx, d);
}
void bintree_insert(pbintree_t self, int d) 
{
     bintree_insert_node(&self->root, d);
}
static void bintree_node_path(pnode_t p, int d)
{
   if (p) {
      if (p->d == d)     
         printf("trovato!\n");             
      else
      if (d<p->d) {
        printf("%d < %d --> sx\n", d, p->d);          
        bintree_node_path(p->sx, d);
      }
      else
      if (d>p->d) {
        printf("%d > %d --> dx\n", d, p->d);          
        bintree_node_path(p->dx, d);
      }      
   } 
   else printf("non trovato!\n");
}
void bintree_showpath(pbintree_t self, int d) 
{
   if (self) {
      printf("ricerca di: %d\n", d);       
      bintree_node_path(self->root, d);
   }
}
static void bintree_destroy_node(pnode_t p) 
{
   if (p) {
      if (p->sx) 
        bintree_destroy_node(p->sx);
      if (p->dx)
        bintree_destroy_node(p->dx);
      free(p);    
   }    
}
void bintree_free(pbintree_t self)
{
   if (self) {
      bintree_destroy_node(self->root);       
      free(self);       
   }  
}
int main()
{
    int i=0;
    pbintree_t bt=bintree_new();
 
    srand(time(0));
 
    for (i=0; i<50; i++)
       bintree_insert(bt, rand()%100);
 
    bintree_showpath(bt, 23);
 
    bintree_free(bt);
 
    system("PAUSE");	
    return 0;
}
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 typedef struct tag_node {
    int d;
    struct tag_node *sx, *dx;   
 } node_t, *pnode_t;
 
typedef di cosa, rincoglionito..
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 typedef di cosa, rincoglionito..
Gente come te non dovrebbe esprimersi su ciò che non conosce.
Se vuoi discutere di C, assicurati di conoscerlo, imbecille.
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 Se vuoi discutere di C, assicurati di conoscerlo, imbecille.
ROTFL, oramai sei fuso


 }
la funzione dovrebbe ritornare un pnode_t ma non ritorna nulla.
 
Tommaso


Si' ormai e' fuso. 


 ROTFL, oramai sei fuso
Sei penoso. Ribatti per il gusto di ribattere, senza avere argomentazioni
tecniche.
Tu stai qui dentro per trollare dichiaratamente e non risponderň piů ai tuoi
messaggi idioti.
Se non hai rispetto per me, abbilo per coloro, qui dentro, che al contrario
di te usano il ng seriamente, per imparare ed apprendere. Tu sei un
ignorante e un deficiente che dal basso della sua anonimia si limita a
sputare cazzate. Rimani nel tuo fondo. Questo č il mio ultimo messaggio col
quale ti mando volentieri a cagare.


 la funzione dovrebbe ritornare un pnode_t ma non ritorna nulla.
Sì, ovviamente deve ritornare self ;-)
Thanks!


 }
Come ha giustamente sottolineato Tommaso, la versione corretta di 
questa funzione č:
pnode_t node_new(int d)
{
    pnode_t self=malloc(sizeof *self);
    if (self) {
       self->d=d;
       self->sx=0;
       self->dx=0;       
    }    
    return self;


 void node_fee(pnode_t self)
 {
      if (self)       /* INUTILE => FUSO */
         free(self);       


  }
Serve in previsione di aggiungere al nodo dei membri da liberare.
Il codice lo scrivo mantenendo una mia coerenza.


 }
Altra piccola correzione:
free(p); --> node_free(p);
;-)


 Sempre gentile ed educato :-(
Le provocazioni non ammettono buona educazione, coglione.
Ultimo messaggio anche per te, imbecille.


Ti ho gia` detto che tacero` quando la smetterai di offendermi
