Newsgroup: it.comp.lang.c
Titolo: programma sugli alberi binari

Nel programma sottostante definisco un puntatore
a Node che chiamo BinarySearch,
qual'è esattamente la differenza (ad esempio):
 
int Cancel(BinarySearch *B,BaseStructure A);
int Recover(BinarySearch B, BaseStructure *A);
 
tra:
BinarySearch *B, e BinarySearch B
nei due prototipi qua sopra riportati?
 
grazie, ciao, Jasmine
 
#include <string.h>
#include<stdio.h>
 
#define Stop "."
 
#include <stdlib.h>
 
typedef int boolean;
 
typedef struct Structure{
 
     char key[16];
     char string[60];
 
}BaseStructure;
 
typedef struct TNode{
     BaseStructure Data;
     struct TNode *Sx,*Dx;
}Node;
 
typedef Node *Position;
typedef Position BinarySearch;
 
void Take(BaseStructure *A);
void TakeKey(BaseStructure *A);
void View(BaseStructure A);
boolean Less(BaseStructure A, BaseStructure B);
boolean BaseStructureNull(BaseStructure A);
boolean Equal(BaseStructure A, BaseStructure B);
void Create(BinarySearch *B);
int Insert(BinarySearch *B, BaseStructure A);
void OrderView(BinarySearch B);
int Cancel(BinarySearch *B,BaseStructure A);
int Recover(BinarySearch B, BaseStructure *A);
int State;
 
Position SearchFind(BinarySearch B, BaseStructure A);
void   CancelMin(BaseStructure *Mim, BinarySearch *B);
 
void Create(BinarySearch *B){
   /*Inizializzazione del nodo*/
     (*B)=NULL;
 
}
int Insert(BinarySearch *B, BaseStructure A){
 
     State=1;
 
     if(*B==NULL){
         /*"istanziazione" del nodo*/
         (*B)=(BinarySearch)malloc(sizeof(Node));
         (*B)->Data=A;
         (*B)->Sx=NULL;
         (*B)->Dx=NULL;
 
         State=0;
 
     }
     else if(Less(A,(*B)->Data))
         Insert(&(*B)->Sx,A);
     else
         if(Less((*B)->Data,A))
             Insert(&(*B)->Dx,A);
     return State;
}
 
 
Position SearchFind(BinarySearch B, BaseStructure A) {
     State=0;
 
     if(B==NULL){
 
        return NULL;
 
     }
     else if (Equal(B->Data,A))
         return (Position)B;
     else if (Less(A,B->Data))
         return (Position)SearchFind(B->Sx,A);
     else
         return (Position)SearchFind(B->Dx,A);
}
 
 
int Recover(BinarySearch B, BaseStructure *A) {
     Position P;
     if(P=SearchFind(B,(*A))){;
     *A=(P->Data);
     return State;}
     else return 1;
}
 
 
int Cancel(BinarySearch *B, BaseStructure A) {
     Position Temp;
     BaseStructure Min;
     State=0;
     if ((*B)==NULL){
         return 1;}
     else if (Less(A,(*B)->Data))
         Cancel(&(*B)->Sx,A);
     else if (Less((*B)->Data,A))
         Cancel(&(*B)->Dx,A);
     else {
         if (((*B)->Sx!=NULL) && ((*B)->Dx!=NULL))
         {
             CancelMin(&Min,&(*B)->Dx);
             (*B)->Data=Min;
         }
         else
         {
             Temp=(*B);
             if ((*B)->Sx!=NULL)
                 (*B)=(*B)->Sx; /* solo sottoalbero sinistro*/
             else
                 if ((*B)->Dx!=NULL)
                     (*B)=(*B)->Dx; /* solo sottoalbero destro */
                 else /* il Nodo e' una foglia:la elimino */
                     (*B)=NULL;
             free(Temp)/*rilascio la memoria*/;
         }
     }
     return State;
}
 
 
 
void   CancelMin(BaseStructure *Min, BinarySearch *B){
     Position Temp;
     if ((*B)!=NULL)
         if ((*B)->Sx!=NULL)
             CancelMin(Min,&(*B)->Sx);
         else
         { /* B punta al minimo */
 
             Temp=*B;
             *Min=(*B)->Data;
             *B=(*B)->Dx;
             free(Temp);
         }
}
 
void OrderView(BinarySearch B) {
     if (B!=NULL)
     {
         OrderView(B->Sx);
         View(B->Data);
         OrderView(B->Dx);
     }
}
 
 
void Take(BaseStructure *A){
     printf("inserire una chiave, massimo 15 caratteri  ");
     scanf("%s", &(A->key));
     if (!BaseStructureNull(*A)){
         printf("inserire il valore massimo 59 caratteri ");
         scanf("%s", &(A->string));
     }
}
void Takekey(BaseStructure *A){
     printf("inserire la chiave, massimo 15 caratteri ");
     scanf("%s", &(A->key));
}
void View(BaseStructure A){
     printf("key: %s\tinfo:%s\n",A.key,A.string);
}
 
boolean Less(BaseStructure A,BaseStructure B){
     return (strcmp(A.key,B.key)<0);
 
}
boolean BaseStructureNull(BaseStructure A){
     return !strcmp(A.key,Stop);
}
boolean Equal(BaseStructure A,BaseStructure B){
     return !strcmp(A.key,B.key);
}
 
int main(void){
     BaseStructure A;
     BinarySearch B;
     Create(&B);
     printf("digitare . per terminare qualsiasi ciclo\n");
     printf("inserire caratteri senza spazi\n");
     printf("Ciclo di inserimento\n");
     do {
         Take(&A);
         if (!BaseStructureNull(A)){
             if(Insert(&B,A)) /*se il val ritornato e' 1*/
                 printf("chiave gia' esistente\n");
         }} while (!BaseStructureNull(A));
     OrderView(B);
     printf("Ciclo di ricerca\n");
     do { /*  finche’ BaseStructure non e' nullo */
         Takekey(&A);
         if (!BaseStructureNull(A)){
             if(Recover(B,&A)){/* viene ritornato 1 */
                 printf("chiave errata\n");
             }
             else{
                 View(A);
             }
         }
     } while (!BaseStructureNull(A));
 
     printf("Ciclo di Cancellazione: se la chiave e' errata vengono 
riproposti tutti i dati\n");
     do {
         Takekey(&A);
         if (!BaseStructureNull(A)){
             if(Cancel(&B,A)){/*viene ritornato 1*/
                 printf("non ci sono dati\n");
             }
             else OrderView(B); /* ordina e quindi visualizza */
         }
     } while (!BaseStructureNull(A));
     printf("Premi un tasto per uscire ");
     getch();
     return 0;
}

 
 
Da qui in poi volevo commentare ma evidentemente anche te ti sei confuso con i tipi di dati, e non hai nemmeno fatto uno schemino come quello di sopra.
 
Il mio consiglio generale è di provare a riscrivere tutto in maniera ordinata, e non utilizzare typedef che mascherano quello che un dato realmente è.
 
Ciao!

 Position, BinarySearch sono puntatori
 
(ps: il reply in mail � un errore!)
 
 
questo per� lo sapevo gi�...
 
non riesco a formulare la domanda in maniera
da chiedere esattamente cio' che mi serve...
prover� a riscrivere il codice senza typedef
come tu suggerisci (sebbene mi sia difficile
considerare i tipi booleani come semplici interi :p
abituata a linguaggi come C# e Java)
 
ciao, Jasmine