C/C++ - Linked list

Ho un nuovo problema: ho implementato una linked list unidirezionale alla quale rimuovo elementi dalla testa e ne aggiungo di nuovi in coda. Funziona tutto bene se creo una lista sola, mentre se ne creao una, la cancello e poi ne creo un'altra non capisco più cosa fa!Queste sono le funzioni:

typedef struct node
{
int x;
int y;
struct node* next;
} pNode;

void initList(int x, int y)
{
head = (pNode*)malloc(sizeof(pNode));
tail = (pNode*)malloc(sizeof(pNode));

if(head!=NULL)
{
head->x = x;
head->y = y;
}
else
{
printf("\nError while creating the list";
getchar();
exit(1);
}
tail = head;
}

// adds an element at the end of the list
void addNode(int x, int y)
{
pNode* toAdd = (pNode*)malloc(sizeof(pNode));

if(toAdd!=NULL)
{
tail ->next = toAdd;
toAdd->next = NULL;
toAdd->x = x;
toAdd->y = y;
tail = toAdd;
}
else
{
printf("\nError while adding the new node to the address %p", toAdd);
getchar();
exit(1);
}
}

// removes the first element of the list
void removeHead( )
{
pNode* toDelete = head;

if(toDelete->next==NULL)
{
printf("\nThe list is empty";
head = NULL;
}
else
head = toDelete->next;

free(toDelete);
}

void printList()
{
int i=1;
pNode* tmp = head;
printf("\n\nPRINTING THE LIST\n";

while(tmp!=NULL)
{
printf("\nThe %dth element is: x:%d y:%d", i++, tmp->x, tmp->y);
tmp = tmp->next;
}
printf("\n";
}


void freeList()
{
pNode* tmp = head;

while(tmp!=NULL)
{
free(tmp);
tmp = tmp->next;
}
}

Il programma fa per prima cosa
initList(x, y);
poi una serie di addNode(x,y) e removeHead()
infine freeList().
A questo punto rifaccio il procedimento da capo.

In pratica sembra che la testa non venga mai cancellata...inoltre non ho la certezza che sia la lista la parte sbagliata, quindi vi chiedo se potete dare un occhio al codice e dirmi se è corretto! Grazie...

Da quello che riesco a capire, l'unico modo per fare funzionare queste funzioni è avere una lista globale, definita fuori dalle funzioni e anche fuori dal main...
Questa implementazione è parecchio strana... Naturalmente possibile ma parecchio strana... io ti consiglio di usare delle liste "normali". cioè nel tuo programma non puoi creare più di una lista... Volendo usando liste "normali" puoi comunque renderle globali e puoi renderne globali più di una senza dover ridefinire una funzione per lista....

Ho sempre usato liste globali, pensavo fossero l'unico modo...e inoltre non mi serve avere più liste allo stesso momento(anzi lo volevo evitare)...
Comunque ho risolto il tutto, portando una piccola modifica alla funzione di inizializzazione e alla condizione di un ciclo while che gestiva la lista!

In rete trovi tantissima "documentazione" su come fare liste in C e in altri linguaggi...
ti posto il primo risultato ke ho trovato cn google:
programmazione.html.it/guide/lezione/1111/introduzione-alle-liste/
Forse è un minimo più difficile perchè devi considerare il concetto di puntatore e che un argomento passato come parametro può essere modificato dalla funzione.

Quando hai capito la dinamica delle liste e soprattuto dei puntatori dai un occhiata qui:
disi.unige.it/person/CostaG/ASD_06_07/esercizi_esami_eccetera/liste/
questo sito contiene varie implementazioni li liste:
-- liste semplici, realizzate in 4 modi
- liste_semplici.c : funzioni e procedure quasi tutte iterative [QUESTO IL METODO STANDARD]
- rec_liste : versione ricorsiva del precedente
- liste_sempli_2.c : procedure quasi tutte iterative
- rec_liste_2 : versione ricorsiva del precedente
-- liste ordinate
-- liste ordinate "con header"
-- liste ordinate, doppiamente linkate
Penso ke sia mooolto completo.