Newsgroup: it.comp.lang.c
Titolo: Delucidazioni alberi binari...

Salve a tutti e grazie delle risposte...
Ho tentato di scrivere un programmino che prendesse in input una sequenza 
di numeri in un ciclo infinito che termina allorche' inserisco 0...
Ogni numero che inserivo volevo fosse posto nel giusto ordine nell'albero 
binario e allorche' inserivo 0, volevo che la funzione inorder mi stampasse 
la sequenza dei numeri inseriti ordinata in ordine crescente...
Comunque il programma e' il seguente:
=========================================================================
#include <stdio.h>
#include <stdlib.h>
struct intree
{
        int dato;
        struct intree *left, *right;
};
typedef struct intree inttree;
void inorder(inttree *root)
{
        if(root!=NULL)
                {
                        inorder(root->left);
                        printf(" \n Numero: %d",root->dato);
                        inorder(root->right);
                }
}
void TreeInsert(inttree *root,inttree *z)
{
        inttree *y,*x;
        y=NULL;
        x=root;
        while(x!=NULL)
                {
                        y=x;
                        if(z->dato<x->dato)
                                x=x->left;
                        else
                                x=x->right;
                }
        z=y;
        if(y==NULL)
                root=z;
        if(z->dato<y->dato)
                y->left=z;
        else
                y->right=z;
}
inttree* newnode()
{
        return(malloc(sizeof(inttree)));
}
main()
{
        int k;
        inttree *root=NULL, *z=NULL;
        while(1)
        {
                printf("\nInserisci un numero(0 per terminare): ");
                scanf("%d",&k);
                if(k==0)
                {
                printf("\n-----------------INORDER--------------------\n");
                inorder(root);
                printf("\n");
                exit(1);
                }
                z=newnode();
                z->dato=k;
                z->left=NULL;
                z->right=NULL;
                printf("\nZ vale: %d\n",z->dato);
                if(root==NULL)
                        {
                                root=newnode();
                                root->dato=k;
                                root->left=NULL;
                                root->right=NULL;
                        }
                else
                        TreeInsert(root,z);
                free(z);
        }
}
===============================================================================
Il programma si blocca se inserisco per esempio 543 654 765 (e penso sia 
giusto, poiche' il nodo sinistro deve essere minore della radice) ma anche 
inserendo sequenze corrette dopo un po' inspiegabilmente si blocca...
Se inserisco per esempio 67 78 32 e poi 0, la procedura inorder mi stampa 
67 in un loop infinito...
Sicuramente penso che l'errore sia in TreeInsert: faccio presente che l'ho 
ricopiata da un libro prestatomi(era scritta in metalinguaggio e percio' 
l'ho riadattata)... La funzione inorder dovrebbe essere giusta...
Tuttavia non sono riuscito a capire cosa non vada: da quel (pochissimo) che 
ho capito la TreeInsert confronta il valore del nodo z coi valori di root 
via via discendendo nell'albero, a destra o a sinistra a seconda dei 
risultati dei confronti...
Dov'e' l'errore?
Scusate se stresso su sto argomento, ma vorrei capire dove sbaglio...
Grazie ancore per le risposte...
Steve

 la sequenza dei numeri inseriti ordinata in ordine crescente...
questa dovrebbe andare bene...
attenzione: non inserisce doppioni nell'albero...
ciao,
~*dyablo*~
mail: 
dya...@virgilio.it
--------------------------------------------
typedef struct elemento {
                                     char key;
                                     struct elemento *sx;
                                     struct elemento *dx;
                                    } RECORD;
RECORD *maketree (void)
{ 
RECORD *root= NULL;
int x;
do{
    printf ("insert key: ");
    scanf ("%d", &x);
    if (x)
    root= insert (root, x);
   }while (x);  
inorder(root);
return (root);
}
void insert (RECORD **root, int x)
{ 
if (!(root))
  {
   *root= (RECORD *) malloc (sizof(RECORD));
   (*root)->key= x;
   (*root)->sx= (*root)->dx= NULL;
   }
else
   {
   if (x < (*root)->key)
      insert(&((*root)->sx), x);
   else
       if (x > (*root)->key)
          insert(&((*root)->dx), x);
   }
}
void inorder(RECORD *root)
{
if(root)
 {
 inorder(root->sx);
 printf(" \n%d", root->key);
 inorder(root->dx);
 }
}