/*
* MAIN
*/
int main(int argc, char **argv) {
int temp = 0;
int countercicli = 0;
double tempo_esecuz, inizio;
acquisisci(argc, argv);
nstampa = 0;
fout = fopen(OUTFILE, "w");
fprintf(fout, "**** METODO UNGHERESE **** n\nValori inseriti:\n");
stampa();
inizio = clock();
normalizza();
soluzione_iniziale_duale();
/*finch� ci sono stazioni esposte in partenza*/
while (esistono_a_esposti() != -1) {
/* aggiorno soluzione duale (I J + - e delta) finch� non esistono cammini aumentanti */
while (!cammino_aumentante())
aggiorna_soluzione_duale();
/*a questo punto esiste un cammino*/
incrementa_flusso();
}
tempo_esecuz = clock() - inizio; /* in CLOCKS_PER_SEC */
stampa();
fprintf(fout, "costo totale %d\nTempo di esecuzione %lf\n", costo_totale(), tempo_esecuz);
fclose(fout);
printf("Risultato in OUTFILE\n");
/*system("pause");*/
return 0;
}
//stampa in profondità
void stampa(nodo* radice){
if(radice!=NULL){
printf("\nRadice %d albero DX",radice->dato);
stampa(radice->DX);
printf("\nRadice %d albero SX",radice->dato);
stampa(radice->SX);
}
};
int main()
{
int n,i;
printf("Inserisci grandezza del vettore:");
scanf("%d",&n);
V=(int *)malloc(sizeof(int)*n);
srand(time(NULL));
for(i=0;i<n;i++)
V[i]=rand()%100;
stampa(n);
mergesort(0,n-1);
stampa(n);
}
/**
* Creo soluzione iniziale duale con minimi di riga e colonna. Miglioro soluzione rp
*/
void soluzione_iniziale_duale() {
int min, i, j;
/*per ogni riga*/
for (i = 0; i < m; i++) {
/*cerco il minimo di riga*/
min = MCosti[i][0];
for (j = 1; j < n; j++)
if (MCosti[i][j] < min) min = MCosti[i][j];
/*scrivo il minimo nel vettore u^*/
u_duale[i] = min;
/*tolgo minimo alla riga*/
for (j = 0; j < n; j++)
MCosti[i][j] = MCosti[i][j] - min;
}
/*per ogni colonna*/
for (j = 0; j < n; j++) {
/*cerco il minimo di colonna*/
min = MCosti[0][j];
for (i = 1; i < m; i++)
if (MCosti[i][j] < min) min = MCosti[i][j];
/*scrivo il minimo nel vettore v^*/
v_duale[j] = min;
/*tolgo minimo alla colonna*/
for (i = 0; i < m; i++)
MCosti[i][j] = MCosti[i][j] - min;
}
fprintf(fout, "RP con costi = Cij-Uij-Vij:\n");
stampa();
stampa_soluz_duale();
/* miglioro soluzione PR */
for (i = 0; i < m; i++)
for (j = 0; j < n; j++)
if (MCosti[i][j] == 0) {
min = minimo(a[i], b[j]);
X[i][j] = min;
a[i] -= min;
b[j] -= min;
}
fprintf(fout, "Soluzione iniziale di RP");
stampa();
}
int
main()
{
int *v1 = NULL;
v1 = malloc(sizeof(int)*NELEMENTI)
leggiVett(v1);
printf("Prima: ");
stampa(v1);
checkMerda(v1);
printf("Dopo : ");
stampa(v1);
sleep(5000); // mette in pausa per 5 secondi cosi leggete scemi.
free(v1);
return 0;
}
void stampa(int n) {
if (n == 0)
return;
else {
stampa(n - 1);
putchar('a' + n - 1);
}
}
//Stampa ricorsiva di una lista
void stampa(struct lista *p)
{
if(p != NULL)
{
printf("%c->",p->car);
stampa(p->next);
}
}
int main()
{
ppiano p = NULL;
stampa(p);
add(&p, 1.0,3.0);
add(&p, 1.0,2.0);
add(&p, -1.0, 4.0);
add(&p , 0.0, 1.0);
stampa(p);
printf("\n\nProva di cancellazione");
del(&p, 0.0,0.0, 3);
stampa(p);
return 0;
}
int main(void) {
int n;
printf("n: ");
scanf("%d", &n);
stampa(n);
printf("\n");
return 0;
}
void stampa(char *s) {
int main(void) {
char stringa[] = "UNIX Programming with POSIX";
/* La memset puo' essere utilizzata, ad esempio, per azzerare un array,
tuttavia c'e' una sottile considerazione da porre in essere:
se si utilizza il numero 0 la stringa sara' effettivamente azzerata, se
invece si utilizza il carattere 0 l'array sara' riempito di tanti zeri. */
int n_zero = 0;
char c_zero = '0';
int size = strlen(stringa);
/* Azzero l'array */
memset(stringa, c_zero, size);
stampa(stringa);
/* Inserisco per ogni byte uno zero */
memset(stringa, n_zero, size);
stampa(stringa);
return(EXIT_SUCCESS);
}
void log_replay (int fd, struct hashtable *db) {
char key[128], value[128];
int k_len,v_len;
while(1) {
if (read(fd, &k_len, sizeof(int)) != sizeof(int)) break;
if (read(fd, &v_len, sizeof(int)) != sizeof(int)) break;
if (read(fd, key, k_len) != k_len) break;
if (read(fd, value, v_len) != v_len) break;
hashtable_insert(db, key, value, k_len, v_len);
printf("replay key\n ");
stampa(key, k_len);
}
}
int main()
{
char stringa[20];
int i;
struct lista *inizio=NULL;
printf("Inserisci la stringa: ");
scanf("%s",stringa);
for(i=0; i < strlen(stringa); i++)
inizio = ins_coda(inizio,stringa[i]);
printf("h->");
stampa(inizio);
printf("NULL\n");
inizio = inverti(inizio);
printf("h->");
stampa(inizio);
puts("NULL");
return 0;
}
int main(void)
{
int n,l,i;
printf("Inserisci lunghezza stringa:");
scanf("%d",&n);
V=(int *)malloc(sizeof(int)*n);
srand(time(NULL));
for(i=0;i<n;i++)
V[i]=rand()%10;
stampa(n);
l=sottosequenza(n,0);
printf("La piu lunga sottosequenza è formata da:%d",l);
}
int main(){
//creo l'albero binario
nodo* radice = crea_nodo();
printf("\nSi vuole inserire dei figli?");
//non entra nel ciclo ma la funzione decisiione all'infinito
while(decisione()){
printf("\nSi procede con l'inserimento di %d\n",n_vet);
alloca_figlo(radice);
printf("\nContinuare?");
}
stampa(radice);
return 0;
}
int main(int argc, const char * argv[])
{
int **m, i, j,n,loop ;
int somRiga,somColonna,somDiagonale,magica;
magica=0;
somRiga=0;
somColonna=0;
somColonna=0;
srand((unsigned)time(NULL));
printf("Inserire la dimensione della matrice: ");
scanf("%d", &n);
int n_quadrato= pow(n,2);
for (loop=0; loop<=1000; loop++) {
m=(int **)malloc(sizeof(int *)*n);
for(i=0; i<n; i++)
m[i]=(int *)malloc(sizeof(int)*n);
for(i=0; i<n; i++){
for(j=0; j<n; j++){
m[i][j]=rand() % n_quadrato+1;
}
}
stampa(m, n);
somRiga=somma_riga(m, n);
somColonna=somma_colonne(m, n);
somDiagonale=somma_diagonale(m,n);
if (somColonna==somRiga && somDiagonale==somColonna) {
printf("matrice magica\n");
magica++;
}
}
printf("le matrici magiche sono:%d\n",magica);
printf("la percentuale di successi è: %d %% \n",media(magica));
return 0;
}
int main () {
int m, n, i;
int *a, *b, *c;
printf ("Inserisci la lunghezza del primo vettore \n");
scanf ("%d", &m);
a = calloc (m, sizeof(int));
printf ("Inserisci la lunghezza del secondo \n");
scanf ("%d", &n);
b = calloc (n, sizeof(int));
printf ("Inserisci il primo vettore \n");
for (i = 0; i < m; i++) {
printf ("Inserisci l'elemento in posizione %d \n", i);
scanf ("%d", &a[i]);
if (i != 0)
while (a[i] < a[i-1]) {
printf ("Errore! Vettore non ordinato, inserisci nuovamentel'elemento");
scanf ("%d", &a[i]);
}
}
printf ("Inserisci il secondo vettore \n");
for (i = 0; i < n; i++) {
printf ("Inserisci l'elemento in posizione %d \n", i);
scanf ("%d", &b[i]);
if (i != 0)
while (b[i] < b[i-1]) {
printf ("Errore! Vettore non ordinato, inserisci nuovamentel'elemento");
scanf ("%d", &b[i]);
}
}
c = calloc(n + m, sizeof(int));
merge (a, b, c, m, n);
stampa(c,n+m);
}
int main()
{
quadri *db=NULL;
int n=0,risp;
do
{
printf("-- MENU' --\n1. Inserisci dati\n2. Carica dati\n3. Scrivi dati ordinati\n4. Visualizza dati\n5. Numero totale quadri con altezza e larghezza maggiore\n6. Esci\nRisposta: ");
scanf("%d",&risp);
switch(risp)
{
case 1:
db=inserisci_dati(db,&n);
break;
case 2:
db=carica_dati(db,&n);
break;
case 3:
db=scrivi_dati(db,n);
break;
case 4:
stampa(db,n);
break;
case 5:
totale(db,n);
break;
case 6:
break;
default:
printf("Risposta errata!\n");
break;
};
}while(risp != 6);
free(db);
return 0;
}
quadri *carica_dati(quadri *db, int *n)
{
FILE *f;
if((f=fopen(nomefile,"rb")) != NULL)
{
while(!feof(f))
{
db=(quadri*)realloc(db,((*n)+1)*sizeof(quadri));
fread((db+(*n)),sizeof(quadri),1,f);
(*n)++;
}}
else
{
printf("File impossibile da aprire!\n");
exit(1);
}
db=ordina(db,*n);
stampa(db,*n);
fclose(f);
return db;
}
int main()
{
int *A,num,i;
printf("Quanti elementi vuoi inserire ?\nRisposta: ");
scanf("%d",&num);
A = (int*)malloc(num*sizeof(int));
printf("- Inserisci gli elementi dell'array -\n");
for(i=0; i < num; i++)
{
printf("Valore %d: ",i);
scanf("%d",&A[i]);
}
stampa(A,num);
//Mettiamo num-1 perché così non inizia da num ma da num - 1 dato che un array va da 0 ad n-1
printf("La somma degli elementi del vettore A e': %d\n",somma(A,num-1));
return 0;
}
/**
* Test per verificare la corretta esecuzione di vari metodi fondamentali. (utilizzo
* di stampa come procedura d'appoggio).
*/
void testValueGetSetOperator(){
cbuffer<int> cb1(5);
cbuffer<float> cb2(4,2.2);
cbuffer<std::string> cb3(3,"stringa");
std::cout << "test get_size() e get_items(): " << std::endl;
std::cout << "cb1 size: " << cb1.get_size() << std::endl;
std::cout << "cb2 size: " << cb2.get_size() << std::endl;
std::cout << "cb3 size: " << cb3.get_size() << std::endl;
std::cout << "cb1 items: " << cb1.get_items() << std::endl;
std::cout << "cb2 items: " << cb2.get_items() << std::endl;
std::cout << "cb3 items: " << cb3.get_items() << std::endl;
std::cout << "test get_cbuffer(size_type) e set_cbuffer(size_type, const &T):" << std::endl;
cb2.set_cbuffer(3, 4);
std::cout << "cb2[3] set 4 " << std::endl;
std::cout << "cb2[3] get: " << cb2.get_cbuffer(3) << std::endl;
std::cout << "test T& value(size_type index):" << std::endl;
cb3.value(0)="fiorellino";
std::cout << "scrittura cb3.value(0)"<< std::endl;
std::cout << "lettura cb3.value(0)= " << cb3.value(0) << std::endl;
std::cout << "test operator[]" << std::endl;
cb3[2]="alberello";
std::cout << "scrittura cb3[2] " << std::endl;
std::cout << "lettra cb3[2] " << cb3[2] << std::endl;
std::cout << "stampa(const cbuffer<int>)" << std::endl;
cbuffer<int> cb4(6);
cb4.insert(1);
cb4.insert(2);
cb4.insert(3);
cb4.insert(4);
std::cout << cb4 << std::endl;
stampa(cb4);
}
int main(void) {
Data d1, d2;
printf("Inserisci la prima data, formato dd/mm/YYYY: ");
scanf("%d / %d / %d", &(d1.giorno), &(d1.mese), &(d1.anno));
fflush(stdin);
printf("\nInserisci la seconda data, formato dd/mm/YYYY: ");
scanf("%d / %d / %d", &(d2.giorno), &(d2.mese), &(d2.anno));
switch(confronta(d1, d2)) {
case 0:
printf("La data ");
stampa(d1);
printf(" e' uguale alla data ");
stampa(d2);
printf("!\n");
break;
case 1:
printf("La data ");
stampa(d1);
printf(" e' antecedente alla data ");
stampa(d2);
printf("!\n");
break;
case -1:
printf("La data ");
stampa(d1);
printf(" e' successiva alla data ");
stampa(d2);
printf("!\n");
break;
}
free(test);
return 0;
}
int main(void) {
int numero = leggi();
stampa(numero);
return 0;
}
/*Legge la mossa del giocatore*/
void leggimossa() {
int tasto=0;
fflush(stdin);
/*Se è attivo il tastierino*/
if(tastierino==1) {
do {
tasto=0;
fflush(stdin);
/*2 giocatori*/
if(scelta==2)
printf("%-59s%s%s\n", GIALLO, "Fai la tua mossa:", BIANCO);
else
printf("%58s%s %d\n%-55s%s%s\n", GIALLO, "Gioca il giocatore", giocatore, "", "Fai la tua mossa:",BIANCO);
if(os)
tasto=mgetchar();
else
do {
tasto=getch();
} while(kbhit());
switch(tasto) {
case 49: {
i=2;
k=0;
break;
}
case 50: {
i=2;
k=1;
break;
}
case 51: {
i=2;
k=2;
break;
}
case 52: {
i=1;
k=0;
break;
}
case 53: {
i=1;
k=1;
break;
}
case 54: {
i=1;
k=2;
break;
}
case 55: {
i=0;
k=0;
break;
}
case 56: {
i=0;
k=1;
break;
}
case 57: {
i=0;
k=2;
break;
}
}
if(tabella[i][k]==1 || tabella[i][k]==2 || i<0 || k<0 || i>=M || k>=M) {
system(clear);
stampa();
printf("%-59s%s%s\n\n", GRASSETTO ROSSO, "Mossa non valida, riprova.", RESET BIANCO);
}
} while(tabella[i][k]==1 || tabella[i][k]==2 || i<0 || k<0 || i>=M || k>=M);
}
/*Mossa con coordinate*/
else {
do {
/*Giocatore singolo*/
if(scelta==2)
printf("%-63s%s\n%-40s%s%s %s%s\n", GIALLO, "Tocca a te.", "", "Inserisci coordinate della mossa", ROSSO, "[Riga,colonna]:", BIANCO);
/*2 giocatori*/
else
printf("%-58s%s %d\n%-40s%s %s%s%s\n", GIALLO, "Gioca il giocatore", giocatore, "", "Inserisci coordinate della mossa", ROSSO, "[Riga,colonna]:", BIANCO);
scanf("%d,%d",&i,&k);
if(tabella[i][k]==1 || tabella[i][k]==2 || i<0 || k<0 || i>=M || k>=M) {
system(clear);
stampa();
printf("\n\n%-56s%s%s\n\n\n", GRASSETTO ROSSO, "Coordinate non valide, riprova.", RESET BIANCO);
}
} while(tabella[i][k]==1 || tabella[i][k]==2 || i<0 || k<0 || i>=M || k>=M);
system(clear);
}
}
/*
* step2 algo ungherese. Cerca il cammino aumentante e lo ricostruisce.
*
* 1=cammino trovato 0 =cammino non trovato
*/
int cammino_aumentante() {
int i, j;
elemento_coda_t *elem_coda_temp;
int k;
int direz;
int cammino_trovato = 0;
t = -1;
reset_etichette(); /*serve ???? */
/*reset coda stazioni*/
reset_coda(&uscita_coda_stazioni, &ingresso_coda_stazioni);
/*trovo prima stazione di partenza esposta*/
s = esistono_a_esposti();
ps[s] = 0;
metti_in_coda(&uscita_coda_stazioni, &ingresso_coda_stazioni, s, 'o');
fprintf(fout, "\nRicerco cammino...\n");
while (cammino_trovato != 1 && !is_coda_vuota(uscita_coda_stazioni, ingresso_coda_stazioni)) {
/* tolgo ultimo elemento dalla coda (primo elemento K da LIST
* secondo procedura cam.aument.) */
elem_coda_temp = togli_da_coda(&uscita_coda_stazioni, &ingresso_coda_stazioni);
k = elem_coda_temp->indice_k;
direz = elem_coda_temp->direzione;
/* se k � una origine ... */
if (direz == 'o') {
/* per ogni el. della riga*/
for (j = 0; j < n && !cammino_trovato; j++)
/* se ha costo nullo, non � stata etichettata ... */
if (MCosti[k][j] == 0 && pd[j] == -1) {
/*metto etichetta*/
pd[j] = k + 1;
if (b[j] == 0)
metti_in_coda(&uscita_coda_stazioni, &ingresso_coda_stazioni, j, 'd');
else {
t = j;
cammino_trovato = 1;
/*TROVATO CAM.AUM. => esco dal ciclo principale*/
}
}
} else {
/* per ogni el. della colonna*/
for (i = 0; i < m; i++)
/* se ha costo nullo, non � stata etichettata e c'� un flusso */
if (MCosti[i][k] == 0 && ps[i] == -1 && X[i][k] > 0) {
ps[i] = k + 1;
metti_in_coda(&uscita_coda_stazioni, &ingresso_coda_stazioni, i, 'o');
}
}
}
stampa();
/* se ho trovato un cammino... */
if (cammino_trovato) {
fprintf(fout, "Cammino trovato !\n");
/* cammino trovato (t � stato gi� impostato)*/
return 1;
} else {
t = 0;
fprintf(fout, "Cammino NON trovato, aggiorno la soluzione !\n");
/*cammino non esistente*/
return 0;
}
}
void client_loop (int cfd) {
char buffer[2048];
while (1) {
ssize_t rd;
if ((rd = read(cfd, buffer, 128)) <= 0) {
perror("read()");
break;
}
if (memcmp(buffer, "scus", 4) == 0) {
memcpy(buffer, "figur\n", 6);
rd = 6;
} else if (memcmp(buffer, "chiudi", 6) == 0) {
break;
} else if (memcmp(buffer, "put", 3) == 0) {
printf("Byte letti %d\n", rd);
char *key, *value;
int k_len, v_len;
key = buffer + 4;
printf("key = %p\n",key);
value = memchr(buffer + 4, ' ', rd - 4) +1;
k_len =(value - key) - 1;
v_len = rd - 4 - k_len - 1;
printf("Key = ");
stampa(key, k_len);
printf("Value = ");
stampa(value, v_len);
/*int i_key;
i_key = strtol(key, NULL, 10);
printf("integer key = %d\n", i_key);*/
hashtable_insert(&db, key, value,k_len, v_len);
log_insert(log_fd, key, value,k_len, v_len);
memcpy(buffer, "storato\n", 8);
rd = 8;
} else if (memcmp(buffer, "get", 3) == 0) {
char *g_key, *g_value;
int g_key_len, v_len;
g_key = buffer + 4;
g_key_len = rd - 4;
//ig_key = strtol(g_key, NULL, 10);
g_value = hashtable_get(&db, g_key, g_key_len, &v_len);
memcpy(buffer, g_value, v_len);
memcpy(buffer + v_len, "\n", 1);
rd = v_len + 1;
} else if (memcmp(buffer, "GET", 3) == 0) {
char xbuffer[4096];
read(cfd, xbuffer, sizeof(xbuffer));
memcpy(buffer, html, strlen(html));
rd = strlen(html);
} else {
memcpy(buffer + rd, "culo\n", 5);
printf("il buffer %s\n", buffer);
rd += 5;
}
if (write(cfd, buffer, rd) != rd) {
perror("write()");
break;
}
}
close(cfd);
}
int main()
{
struct nodo *list=NULL; //puntatore alla lista
int scelta=1;
for(;;)
{
printf("\n\nMenu:\n\n");
printf("1. Visualizza lista\n");
printf("2. Aggiungi nodo\n");
printf("3. Svuota lista\n");
printf("4. Cerca elemento\n");
printf("5. Elimina un elemento\n");
printf("6. Esci\n");
printf("Scelta: ");
char string[80];
fgets(string, sizeof(string), stdin);
scelta = atoi(string);
/******************************************************************************/
if(scelta==1) //Visualizzazione della lista
{
printf("\n\nVisualizzazione della lista:\n\n");
if( vislist(list, stampa)==0 )
printf("Lista vuota: nessun elemento da visualizzare");
else printf("\n\nFine della lista.");
}
/******************************************************************************/
else if(scelta==2) //Aggiunta di elementi
{
printf("\n\nAggiunta di elementi nella lista\n\n");
printf("Scegli la modalità di inserimento:\n\n");
printf("1. Ordine crescente per nome\n");
printf("2. Ordine crescente per numero\n");
printf("3. Ordine decrescente per nome\n");
printf("4. Ordine decrescente per numero\n");
printf("5. Inserisci in testa\n");
printf("6. Inserisci in coda\n");
printf("\nScelta: ");
int scelta;
scanf("%d", &scelta);
printf("\n\nCreazione di una nuova persona:\n");
struct persona *tmp;
tmp=creapersona(NULL, 3);
if(scelta==1) sortadd(tmp, &list, crescnome);
else if(scelta==2) sortadd(tmp, &list, crescnum);
else if(scelta==3) sortadd(tmp, &list, decrenome);
else if(scelta==4) sortadd(tmp, &list, decrenum);
else if(scelta==5) tohead(tmp, &list);
else if(scelta==6) totail(tmp, &list);
printf("Inserimento effettuato!");
}
/******************************************************************************/
else if(scelta==3) //Svuota la lista
{
printf("\n\nSvuotamento della lista\n\n");
if( byelist(&list, libera)==0 )
printf("\n\nLista già vuota. Nulla da fare.\n\n");
else printf("\n\nLista svuotata.\n\n");
}
/******************************************************************************/
else if(scelta==4) //Ricerca di un valore
{
printf("\n\nRicerca di un elemento:\n\n");
printf("Scegli la modalità di ricerca:\n");
printf("1. Per nome\n");
printf("2. Per numero\n");
printf("3. Per nome e numero (verifica l'esistenza)\n");
printf("Scelta: ");
int scelta;
scanf("%d", &scelta);
//setto le variabili necessarie a seconda della modalità indicata dall'utente
struct persona *confronto, *trovato;
struct nodo *postit;
void *funzi;
if(scelta==1) //vi è corrispondenza tra i numeri del menù e i numeri che stabiliscono la modalità di funzionamento della funzione creapersona; MA è solo una coincidenza: sviluppi futuri potrebbero perdere questa corrispondenza e utilizzare composizioni delle modalità della funzione stessa (richiamare più volte la funzione con modalità diverse per riempire determinati campi)
{
confronto = creapersona(NULL, 1);
funzi=crescnome;
}
else if(scelta==2)
{
confronto = creapersona(NULL, 2);
funzi=crescnum;
}
else if(scelta==3)
{
confronto = creapersona(NULL, 3);
funzi=oggcmp;
}
//la prima chiamata a cerca() deve essere fatta con un puntatore nullo e si deve verificare che venga restituito un valore non nullo, altrimenti significa che l'oggetto non è stato trovato nella lista
postit = NULL;
trovato = cerca( confronto, list, &postit, funzi ); //prima chiama: postit è NULL
if( trovato==NULL ) printf("\n\nValore non trovato nella lista!\n"); //valore non trovato, trovato==NULL
else
{
printf("\n\nElenco delle voci trovate:\n");
do{
stampa(trovato); //stampa l'oggeto trovato
trovato = cerca( confronto, list, &postit, funzi ); //passo successivo nella ricerca
}while( trovato!=NULL );
printf("\n\nFine elenco.\n");
}
free(confronto);
}
/******************************************************************************************/
/*
else if(scelta==5) //Eliminazione di un nodo
{
int val;
struct nodo *tmp;
printf("\n\nEliminazione di un elemento dalla lista\n\n");
printf("Scegli:\n");
printf("1. Elimina un elemento per numero\n");
printf("2. Elimina un elemento dalla testa\n");
printf("3. Elimina un elemento dalla coda\n");
printf("\nScegli: ");
int scelta;
scanf("%d", &scelta);
if(scelta==1)
{
printf("\n\nEliminazione di un elemento per valore\n\n");
printf("Inserisci il campo: numero\n\n");
scanf("%d", &val);
//funzione per l'eliminazione di un determinato elemento
}
else if(scelta==2)
{
printf("\n\nEliminazione di un elemento dalla testa...\n\n");
if( tmp=delhead(list)==NULL ) printf("Lista già vuota: nulla da cancellare.");
else printf("N
}
else if(scelta==3)
{
printf("\n\nEliminazione di un elemento dalla coda...\n\n");
//funzione di un elemento dalla coda
}
}
*/
/******************************************************************************************/
else if(scelta==6) //Uscita dal programma
{
printf("\n\nUscita dal programma\n\n");
exit(0);
}
else printf("\n\nScelta non valida...\n");
/******************************************************************************************/
}
} //FINE MAIN
