Problema esercizio in C

Ciao , ho un problema con un programma in C che deve gestire le prenotazioni delle stanze in un albergo. Ho una lista con il tipo di stanza e il prezzo , alla fine deve stamparmi il nome del tour operator e quanto ha speso in base alle stanze prenotate e al costo di ogni stanza.

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "tabella.h"


SYMBOL       hashtable[HASHSIZE]; //HASH TABLE
TEMP 	     tempElement  = NULL; //prenotazioni Tour operator
TEMP2	     tempElement2 = NULL; //stanze prenotate
TEMP3	     tempElement3 = NULL; //prezzo stanze

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *  Funzione hash. Usata per generare un hash che serve come               *
 *  accesso diretto alla locazione di memoria dell'elemento.               *
 *  La funzione prende come parametro una stringa e genera un              *
 *  intero senza segno attraverso dei calcoli effettuati su tutte          *
 *  le lettere della stringa in modulo della dimensione della              *
 *  symbol table (che è un numero primo), così facendo si ha la certezza   *
 *  che possono essere utilizzate tutte le celle                           *
 *  di memoria messe a disposizione per la symbol table.                   *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 
unsigned int hash(char *nome) {
    unsigned int h = 0;
    for (; *nome != '\0'; nome++) {
        h = (127 * h + *nome) % HASHSIZE;
    }
    return h;
}

/*
 * La funzione di lookup prende in ingresso una stringa e ne ricerca l'elemento
 * corrispondente all'interno della symbol table. Quindi viene generato l'hash
 * corrispondente alla stringa, si recupera l'elemento memorizzato a quell'indirizzo
 * e con il ciclo for si scorre la lista degli elementi in quella posizione. Il ciclo 
 * termina quando l'elemento è NULL o il paramentro "name" corrisponde con l'elemento 
 * ricercato. Nel caso in cui la lista in questa posizione non è ancora assegnata si 
 * esce istantaneamente dal ciclo e viene ritornato l'elemento che in questo caso è NULL.
 */
SYMBOL lookupElement(char *nome) {
    unsigned int h = hash(nome);
    SYMBOL ans = hashtable[h];
    for (; ans != NULL && ans->nome == nome; ans = ans->next);
    return ans;
}

/*******************************************/
/*      INSERIMENTO NELLA HASH TABLE       */
/*******************************************/
SYMBOL insertElement(char *nome , char *codice){
		
		
		SYMBOL ans = lookupElement(nome);

		if(ans == NULL) 
		{
			unsigned int h = hash(nome);
			
			SYMBOL ans = (SYMBOL)malloc(sizeof(symbol));
			if(ans==NULL)
				return NULL;
			else
			{
				
				ans->nome   = strdup(nome);
				ans->codice = strdup(codice);	
				ans->stanze = tempElement2;	
				ans->next = hashtable[h];
				hashtable[h] = ans;
				
			}
		}
		return ans;
}


/*************************************/
/*          STANZE E PREZZI          */
/*************************************/
TEMP3 prezzoStanze(char *stanza , int prezzo)
{

	TEMP3 p = (TEMP3)malloc(sizeof(temp3));
	 
	if(p==NULL)
		return NULL;
	else
	{
		p->stanza = strdup(stanza);
		p->prezzo = prezzo;
		p->next   = tempElement3;
		tempElement3 = p;
	}

	//printf("%s %d\n",p->stanza,p->prezzo);	
	return p;
	free(p);
}



/*************************************/
/*     NUMERO STANZE PRENOTATE       */
/*************************************/
TEMP2 numeroStanze(char *stanza , int numero)
{


	TEMP2 z = (TEMP2)malloc(sizeof(temp2));;
	
	if(z==NULL)
		return NULL;
	else
	{
		z->stanza = strdup(stanza);
		z->numero = numero;
		z->next   = tempElement2;
		tempElement2 = z;
	}	
	
	return z;
	free(z);
}

/*************************************/
/*         PRENOTAZIONI              */
/*************************************/
TEMP prenotazioni(char *nome, char *codice, int num , int inizio, int fine)
{
	int giorni = 0;
	int i=0;
	int somma;
	int speseTotali;
	int sconto;
	
	SYMBOL ans = insertElement(nome,codice);

	TEMP t = (TEMP)malloc(sizeof(temp));
	
	if(t==NULL)
		return NULL;
	else
	{
		t->nome   = strdup(nome);
		t->codice = strdup(codice);
		t->num	  = num;
		t->inizio = inizio;
		t->fine   = fine;
		t->t2 = tempElement2;
		t->spesaGiornaliera = calcoloStanze(t->t2);
		t->next   = tempElement;
		tempElement = t;

		tempElement = NULL;
	}

	

	//calcolo giorni di permanenza in hotel
	for(i=t->inizio; i<=t->fine; i++)
		giorni++;
		
	speseTotali = t->spesaGiornaliera * giorni;
	if(t->num >= 30)
	{
		sconto = (speseTotali*15)/100;
		speseTotali = speseTotali-sconto;
		printf(" %s , %s , spesa: %d\n" , t->nome, t->codice , speseTotali);
	}
	else
	{
		if(t->num > 50)
		{
			sconto = (speseTotali*25)/100;
			speseTotali = speseTotali-sconto;
			printf(" %s , %s , spesa: %d\n" , t->nome, t->codice , speseTotali);
		}
		else
			printf(" %s , %s , spesa: %d\n" , t->nome, t->codice , speseTotali);
	}
	

	return t;
	free(t);
}


//FUNZIONE CALCOLO NUMERO STANZE
int calcoloStanze(TEMP2 c)
{
	int somma;
	TEMP3 t3 = (TEMP3)malloc(sizeof(temp3));
	t3 = tempElement3;


	printf("%s",c->stanza);

	if(c==NULL)
		return -1;
	else
	{
		//lista stanze prenotate
		for(;c!= NULL;c = c->next)
		{
			//lista elenco stanze e prezzi	
			for(;t3!=NULL;t3=t3->next)
			{
				if(strcmp(c->stanza,t3->stanza)==0)
					somma += c->numero * t3->prezzo;
			}
		}
		
	}
	
	return somma;
	
}


/*******************************************/
/*          FUNZIONE PER LIBERARE          */
/*           LA MEMORIA OCCUPATA           */
/*             DALLA TABELLA               */
/*******************************************/
void freeTable() {
    int i;
    SYMBOL s, ans;
    for (i = 0; i < HASHSIZE; i++) {
        if (hashtable[i] != NULL) {
            s = hashtable[i];
            for (; s != NULL; s = s->next) {
                ans = s;
                free(ans);
            }
        }
    }
}

/*************************************************/
/*   Definisco la dimensione della simbol table  */
/*   con un numero primo  che servirà poi        */
/*   per la funzione di hashing.                 */                           
/*************************************************/
#define HASHSIZE 101

/******************************/
/*     STANZE PREZZO          */
/******************************/
typedef struct p{
	char *stanza;
	int  prezzo;
	struct p *next;
}temp3;
typedef temp3 *TEMP3;



/******************************/
/*      NUMERO STANZE         */
/******************************/
typedef struct z{
	char *stanza;
	int  numero;
	struct z *next;
}temp2;
typedef temp2 *TEMP2;



/******************************/
/*   STRUTTURA PRENOTAZIONI   */
/******************************/
typedef struct t{
	char *nome;
	char *codice;
	int  num;
	int  inizio;
	int  fine;
	int  spesaGiornaliera;
	TEMP2 t2;
	struct t *next;
}temp;
typedef temp *TEMP;



/*****************/
/* SYMBOL TABLE  */
/*****************/
typedef struct s{
	char 	*nome;
	char	*codice;
	TEMP2    stanze;
	struct s *next;
}symbol;
typedef symbol *SYMBOL;


TEMP prenotazioni(char *nome, char *codice, int num , int inizio, int fine);
SYMBOL insertElement(char *nome , char *codice);
unsigned int hash(char *s);
SYMBOL lookupElement(char *nome);
TEMP2 numeroStanze(char *stanza , int numero);
int calcoloStanze(TEMP2 c);
void freeTable();

Il problema è nel calcolo prezzo in base al numero delle stanze e del prezzo di ogni tipo di stanza.

Qualcuno può aiutarmi?
Mi stampa questo

---

Allegati: