Salve a tutti, ho costruito un programma che implementa un albero binario di ricerca. Ho provato e riprovato a implementare questo programma e alla fine sono arivato a questa versione che è quella che diciamo, è quella che funziona meglio. Tuttavia non funziona bene lo stesso, perchè non riesce a memorizzare tutti gli elementi. Essa memorizza gli elementi sovrascrivendoli con gli ultimi (praticamente per 3 elementi, mi memorizza 3 elementi uguali all'ultimo). Io penso che il problema sta nella funzione ricerca_modificata ma non riesco a trovarlo (ho provato moltissime volte a modificarla ma questa è quella che funziona di più).
Qualcuno mi sa aiutare?


#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>
typedef char* elemento;
typedef struct nodo *tree_pointer;
typedef struct nodo {
elemento key;
tree_pointer figlio_sinistro;
tree_pointer figlio_destro;
} albero;
tree_pointer radice = NULL;
void preorder(tree_pointer ptr);
void inorder(tree_pointer ptr);
void postorder(tree_pointer ptr);
tree_pointer ric_ric(tree_pointer, char*);
tree_pointer ric_iter(tree_pointer, char* );


int menu(void);

void insert_nodo(tree_pointer *nodo,elemento num);

tree_pointer ric_modificata(tree_pointer , elemento );




main(){
printf("\nEsercitazione numero 14");
char *nome_chiave;
int scelta=100;
do{scelta=menu();
if(scelta==1){
printf("\nscrivi la chiave");
scanf("%s",nome_chiave);
insert_nodo(&radice,nome_chiave);
}

if(scelta==2){ printf("\nElemento da ricercare: ");
scanf("%s",nome_chiave);
if(ric_ric(radice,nome_chiave))
printf("\nTrovato!");
else printf("\nNon è stato trovato!");
}


if(scelta==6)inorder(radice);

if(scelta==7)preorder(radice);

if(scelta==postorder(radice);

} while(scelta!=0);

fflush(stdin);
getchar();
}


int menu(void)
{
int buf;
printf("\n\nIndica l'operazione da eseguire:\n\n");
printf("inserisci elemento --> 1\n");
printf("ricerca elemento (ric.) --> 2\n");
printf("ricerca elemento (iter.) --> 3\n");
printf("cancella elemento per fusione --> 4\n");
printf("cancella elemento per copiatura --> 5\n");
printf("visita inorder --> 6\n");
printf("visita preorder --> 7\n");
printf("visita postorder --> 8\n");
printf("termina --> 0\n");
scanf("%d",&buf);
fflush;
return buf;
}



void insert_nodo(tree_pointer *nodo,elemento num)
{
tree_pointer ptr, temp;
temp = ric_modificata(*nodo, num);
if(temp || !(*nodo)) {
ptr = (tree_pointer)malloc(sizeof(nodo));
if (ptr == NULL) {
printf("\la memoria è piena");
exit(1);
}
strcpy(ptr->key,num);
ptr->figlio_sinistro = NULL;
ptr->figlio_destro = NULL;
if(*nodo) if(strcmp(num,temp->key)<0) temp->figlio_sinistro = ptr;
else temp->figlio_destro = ptr;
else *nodo = ptr;
}
}



tree_pointer ric_modificata(tree_pointer tree, elemento chiave)
{
/* fornisce un puntatore al nodo che contiene item
se tale nodo non esiste fornisce NULL */
if(!tree) return NULL;

while(tree) {
if (strcmp(chiave,tree->key)==0) return NULL;
if (strcmp(chiave,tree->key)<0) {if (tree->figlio_sinistro) tree=tree->figlio_sinistro; else break;}
else {if (tree->figlio_destro) tree=tree->figlio_destro; else break;}
}
return tree;
}



/*algoritmo preorder*/
void preorder(tree_pointer ptr){
if(ptr){
printf("%4s",ptr->key);
preorder(ptr->figlio_sinistro);
preorder(ptr->figlio_destro);
}
}


/*algoritmo inorder*/
void inorder(tree_pointer ptr){
if(ptr){

inorder(ptr->figlio_sinistro);
printf("%4s",ptr->key);
inorder(ptr->figlio_destro);
}
}


/*algoritmo postorder*/
void postorder(tree_pointer ptr){
if(ptr){

postorder(ptr->figlio_sinistro);
postorder(ptr->figlio_destro);
printf("%4s",ptr->key);

}
}

tree_pointer ric_ric(tree_pointer radice, char* str)
{
if (!radice) return (NULL);
if (strcmp(str,radice->key) < 0)
return (ric_ric(radice->figlio_sinistro, str));
return (ric_ric(radice->figlio_destro, str));
}

tree_pointer ric_iter(tree_pointer tree, char* str)
{
while(tree)
{
if (strcmp(str,tree->key) == 0)
return(tree);
if (strcmp(str,tree->key) < 0)
return (ric_iter(tree->figlio_sinistro, str));
else tree = tree->figlio_destro;
}
return (NULL);
}