Il seguente codice permette di fare quanto segue:
Inserendo da tastiera uno alla volta dei valori interi:
Inserisci numero:1
Inserisci numero:0
Inserisci numero:2
a)Ordina la sequenza:
0 1 2
b)Ricerca un valore:
Inserire un numero: 4
Valore non presente!(Dopo aver stampato questo messaggio il programma mi si blocca)
c)Ricerca Min max della sequenza(Le funzioni non partono proprio,in quanto il programma si blocca)
Qualche consiglio?
codice:
#include<stdio.h>
#include<stdlib.h>
struct TInfo{
int num;
};
struct Nodo{
TInfo info;
struct Nodo *destro;
struct Nodo *sinistro;
};
typedef struct Nodo TNodo;
typedef struct Nodo* Albero;
Albero Crea_Albero();
void Distruggi_Nodo(TNodo *nodo);//??//
Albero Inserisci_Elemento(Albero bt,TInfo info);
TInfo Leggi_Info();
Albero Distruggi_Albero(Albero bt);
TNodo *Ricerca(Albero bt,TInfo info);
TNodo *Cerca_Minimo(Albero bt);
TNodo *Cerca_Massimo(Albero bt);
void Stampa_Info(TInfo info);
void Stampa_Albero(Albero bt);
int main(){
Albero bt;/*Rappresenta l'albero binario*/
TInfo info;/*Serve per leggere gli elementi*/
int i,dim;/*Serve per chiedere più elementi*/
TNodo *search,*min,*max;
bt=Crea_Albero();
printf("Quanti elementi vuoi inserire?");
scanf("%d",&dim);
for(i=0;i<dim;i++){
info=Leggi_Info();
bt=Inserisci_Elemento(bt,info);
}
/*STAMPA DELL'ALBERO*/
printf("Elementi dell'albero:");
Stampa_Albero(bt);
/*RICERCA ELEMENTO*/
printf("\n\nRicerca elemento\n");
info=Leggi_Info();
search=Ricerca(bt,info);
if(search==NULL)
printf("Elemento non presente!\n");
else
printf("Elemento presente!\n");
/*RICERCA MINIMO*/
min=Cerca_Minimo(bt);
/*RICERCA MASSIMO*/
max=Cerca_Massimo(bt);
printf("\n\nMinimo:\n");
Stampa_Info(min->info);
printf("\nMassimo:\n");
Stampa_Info(max->info);
printf("\n\n");
system("pause");
return 0;
}
Albero Crea_Albero(){/*Crea un albero vuoto*/
return NULL;
}
void Distruggi_Nodo(TNodo *nodo){
free(nodo);/*Deallocazione dimanica nodo*/
}
TInfo Leggi_Info(){
TInfo info;/*creazione di un tipo TInfo*/
printf("Inserisci numero:");
scanf("%d",&info.num);
return info;
}
Albero Inserisci_Elemento(Albero bt,TInfo info){
if(bt==NULL){/*opzioni che si verificano se il nodo 3è vuoto*/
TNodo *nuovo_nodo;
nuovo_nodo=(TNodo*)malloc(sizeof(TNodo));
nuovo_nodo->info=info;
nuovo_nodo->destro=NULL;/*pongo a null perchè l'albero al momento è vuoto*/
nuovo_nodo->sinistro=NULL;
if(nuovo_nodo==NULL){
printf("Errore di allocazione in memoria!\n");
exit(1);
}
return nuovo_nodo;}
/* se il nodo non e' vuoto*/
else if(info.num<bt->info.num){ /* se l'informazione contenuta nel primo nodo radice bt
è maggiore del numero che voglio inserire...quindi i confronti
vengo fatti due per volta,i valori non sono contenuti già tutt
nella struttura come pensavo.
/*se è vero l'else if devo lavorare nel sottoalbero sinistro,perchè
è sottinteso che l'albero sia in ordine e a sinistra della radice ci sono gli elementi più piccoli*/
bt->sinistro=Inserisci_Elemento(bt->sinistro,info);
return bt;
}
else{
bt->destro=Inserisci_Elemento(bt->destro,info);
return bt;
}
}
void Stampa_Info(TInfo info){
printf("%d ",info.num);
}
void Stampa_Albero(Albero bt){
if(bt!=NULL){
Stampa_Albero(bt->sinistro);
Stampa_Info(bt->info);
Stampa_Albero(bt->destro);
}
}
Albero Distruggi_Albero(Albero bt){
/*Caso base:Albero vuoto o con un solo elemento*/
if(bt==NULL)
return NULL;
else if((bt->sinistro==NULL)&&(bt->destro==NULL)){
free(bt);
return NULL;
}else{
/*Divide et impera*/
bt->sinistro=Distruggi_Albero(bt->sinistro);
/*Divide et impera*/
bt->destro=Distruggi_Albero(bt->destro);
/*Combina*/
Distruggi_Albero(bt);
return NULL;
}
}
TNodo *Ricerca(Albero bt,TInfo info){
/*Caso base:albero vuoto o la radice coincide
con l'elemento che cerchiamo*/
if((bt==NULL) || (bt->info.num==info.num))/*caso banale:albero vuoto oppure l'informazione
contenuta nell'elemento radice bt->info e' uguale
all'elemento che stiamo cercando(che culo)*/
return bt;
else{
/*Dobbiamo verificare se l'elemento che stiamo cercando è meaggiore o minore
dell'elemento contenuto nel nodo che stiamo visitando*/
if(info.num >bt->info.num)/*Se il valore dell'elemento che vogliamo cercare info.num
e' maggiore della radice che stiamo cercando bt->info.num*/
return Ricerca(bt->destro,info);
else
return Ricerca(bt->sinistro,info);
}
}
TNodo *Cerca_Minimo(Albero bt){
/*Caso base:Albero vuoto*/
if(bt=NULL)
return NULL;
else if(bt->sinistro==NULL)
return bt;
else{
Albero min=Cerca_Minimo(bt->destro);
return min;
}
}
TNodo *Cerca_Massimo(Albero bt){
/*Caso base:Albero vuoto*/
if(bt=NULL)
return NULL;
else if(bt->destro==NULL)
return bt;
else{
Albero max=Cerca_Massimo(bt->destro);
return max;
}
}