Problem z listą jednokierunkową

Witam wszystkich, mam problem z moim programem zaliczeniowym, otóż ponizszy kod ma tworzć liste jednokierunkową, nie wiem gdzie jest błąd(gdzieś w tej funkcji musi być....), ale po uruchomieniu programu wyskakuje mi, że "Program wykonał nieprawidłową operację i nastąpi jego zamknięcie, skontaktuj się ze sprzedawcą" - problem jest tym większy, że to ja jestem twórcą programu i jak się kontaktuję z samym sobą to nic mi to nie daje :-) :-D :-D
a oto kod:

[code]/*******************************************************************************

• Fukcja ma za zadanie dodawac trzyliterowe ciagi znakow do slownika, ktory

• jest zaimplementowany, jako lista jednokierunkowa
  *******************************************************************************/
  void dodaj_do_slownika(char ciag[4], struct slownik **glowa2, struct slownik **ogon)
  {
  struct slownik *temp;
  int itemp;

  temp = (struct slownik )malloc(sizeof(struct slownik));
  if(!temp)
  {
  printf("Brak pamieci.\n");
  menu();
  }
  /************************************************************************
  **Ta funkcja liczy 'indexy', czy li kody, ktorymi potem zastapimy znaki w
  **pliku wyjsciowym
  **************************************************************************/
  itemp=policz(glowa);
  //Przypisywanie wartosci strukturze temp
  temp->id = itemp;
  temp->znaki3 = ciag;

  //Tworzenie listy jednokierunkowej...

  if(!*ogon) *ogon = temp;
  else (*ogon)->next = temp;
  (*ogon)->next = NULL;
  *ogon = temp;

}[/code]
Proszę o pomoc i z góry dziękuję.

Kurcze jestem wdzięczny za pomoc, ale nic nie działa, mam pomysł, wyślę poniżej kod prostego programiku, kóry w pascalu by działał, ale w C już nie chce.... proszę o pomoc...
[code]#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct lista{
char imie[20];
struct lista *next;
} imiona;

char name[20];
struct lista *pierwszy_wsk;

void dodaj_do_listy(char *name, struct lista *mylist);
void show(struct lista *pierwszy_wsk);

void main(void)
{
do
{
printf("Podaj imie(kropka aby zakonczyc):\n");
gets(name);
dodaj_do_listy(name, pierwszy_wsk);
printf("****\n");
}while(strcmp(name, "."));

show(pierwszy_wsk);

}

void dodaj_do_listy(char name[20], struct lista *mylist)
{
struct lista *temp_wsk;

 temp_wsk = (struct lista *)malloc(sizeof(struct lista));

 strcpy(temp_wsk->imie, name);
 temp_wsk->next = mylist;
 mylist = temp_wsk;

}

void show(struct lista *pierwszy_wsk)
{
struct lista *teraz;

teraz = pierwszy_wsk;
while(teraz != NULL)
{
printf("%s",teraz->imie);
teraz = teraz->next;
}
}[/code]
W pascalu dodawałoby to kolejne elementy listy na początek niby jest dobrze, ale nie wyświetla mi potem zawartości dlaczego?
Może jeśli to mi ktoś wytłumaczy, to zaskoczę z tym dużym projektem.. :)
Z góry dzięki :P

void dodaj_do_listy(char name[20], struct lista *& mylist)

maly jeden znaczek & (pascalowe var)

a wracając...

struct slownik{
  slownik* next;
  int id;
  char znaki3[4];  // jesli to 4 ...
}

void dodaj_do_slownika(char* ciag,slownik*& glowa){
  slownik* temp=(slownik*)malloc(sizeof(slownik));
  if(!temp){
    printf("Brak pamieci.\n");
    menu();
  }
  strncpy(temp->znaki3,ciag,3)[3]=0;   // ... to tu dwie trojki
  temp->next=0;
  temp->id=0; // to jest liczba od ktorej beda indeksowane kolejne elementy
  slownik* ogon=glowa;
  if(ogon){
    while(ogon->next){   // zeby nie zbubic ogona
      temp->id++;             // liczym id
      ogon=ogon->next;
    }
    ogon->next=temp;
  }
}

slownik* findogon(slownik* glowa){ // gdyby tu byla referencja (&)
  if(!glowa)return 0;
  while(glowa->next)glowa=glowa->next; // to nie moglbys na tej zmiennej operowac w taki sposob.
  return glowa;
}

// sorki, cos ostatnio zbyt wiele sie myle, natomiast ta wersja musi dzialac, łaski nie robi.
// stara odpowiedz do kosza, bo wstyd mi bylo

Witam
Prosiłbym o pomoc także odnośnie listy jednokierunkowej , w ktorej mam problem z usuwaniem. Chodzi o funkcje usun ktora mimo, ze powinna to nie dziala jak nalezy... trudno mi powiedziec dlaczego... dlugo ja juz debuguje i nic z tego nie moge wymyslic. Ponizej zamieszczam swoj kod:

#include <iostream>
using namespace std;

struct ELEMENT
{
int wartosc;
ELEMENT *nastepny;
};

struct INFO
{
ELEMENT *glowa;
ELEMENT *ogon;
};

void zainicjuj(INFO*);
void dodaj(INFO*,int);
void usun(INFO*,int);

void wypisz(INFO);
void szukaj(INFO,int);
void zwolnij(INFO);

int main()
{

INFO lst;
char operacja;
int parametr;

zainicjuj(&lst);

cin >> operacja;

cin >> parametr;

while(operacja!='k')
{
	switch(operacja)
	{
		case 'w':
			wypisz(lst);
			break;
		case 'd':
			dodaj(&lst,parametr);
			break;
		case 's':
			szukaj(lst,parametr);
			break;
		case 'u':
			usun(&lst,parametr);
			break;

	}
	cin >> operacja;
	cin >> parametr;
}
zwolnij(lst);

return 0;

}

void zainicjuj(INFO *wsk_info)
{
wsk_info->glowa=NULL;
wsk_info->ogon=NULL;

}

void zwolnij(INFO lst)
{
ELEMENT *p,*q;
if(lst.glowa!=NULL)
{
q=lst.glowa;
while(q!=NULL)
{
//zapamietujemy wskaznie na nastepny element listy
//w zmiennej p
p=q->nastepny;

		//usuwamy element listy wskazywany przez q
		delete(q);		
		//przypisujemy zmiennej q wskazanie na kolejny element
		q=p;
	}			
}

}

/********************************************************************
Zaimplementuj funkcje dodaj(INFO *lst,int elem), ktora dolaczy element o wartosci
rownej elem na koniec listy.
********************************************************************/
void dodaj(INFO *tmp,int val)
{
ELEMENT *ptr = new ELEMENT;
ptr->wartosc = val; // wpisanie wartości val do nowego elemntu listy
ptr->nastepny = NULL; // wskaznik nowego elementu na NULL
if(tmp->glowa == NULL)tmp->glowa = tmp->ogon = ptr; // stworzenie pierwszego elemenu, glowa = ogon
else
{
tmp->ogon->nastepny = ptr;
tmp->ogon = ptr;
}
}

/********************************************************************
Zaimplementuj funkcje wypisz(INFO lst), ktora wypisze w kolejnych wierszach
zakonczonych znakime nowej linni ("\n") kolejne elementy listy.
********************************************************************/

void wypisz(INFO tmp)
{
ELEMENT *ptr = new ELEMENT;
ptr = tmp.glowa;
if(tmp.glowa == NULL)
{
cout<<"lista pusta\n";
}
else
{
while( ptr != NULL )
{
cout<<ptr->wartosc<<endl;
ptr = ptr->nastepny;
}
}
}

/********************************************************************
Zaimplementuj funkcje szukaj(INFO lst,int elem), ktora sprawdzi,
czy na liscie znajduje sie przynajmniej jeden element o wartosci rownej elem;

• jesli tak, to wypisze na stdout tekst "TRUE",
• jesli nie, to wypisze na stdout tekst "FALSE",
  zakonczony znakiem nowej linni "\n".
  ********************************************************************/
  void szukaj(INFO tmp,int elem)
  {
  ELEMENT *ptr = new ELEMENT;
  int check = 0; // zmienna do porownania czy wystapila
  ptr = tmp.glowa;
  if(tmp.glowa == NULL)cout<<"FALSE - emty list"<<endl;
  else
  {
  do
  {
  if(ptr->wartosc == elem)
  {
  check = 1;
  }
  ptr = ptr->nastepny;
  }
  while(ptr != NULL);
  if(check == 1)cout<<"TRUE"<<endl;
  else cout<<"FALSE"<<endl;
  }
  }

/********************************************************************
Zaimplementuj funkcje usun(INFO* lst ,int elem), ktora usunie z listy wszystkie elementy
o wartości równej parametrowi elem.
********************************************************************/

void usun(INFO *tmp,int value)
{
ELEMENT *ptr = tmp->glowa;

while(ptr->nastepny != NULL)
{
if(ptr->nastepny->wartosc == value)
{
ELEMENT *erase = new ELEMENT;
erase = ptr->nastepny;
ptr->nastepny = erase->nastepny;
delete (erase);
}
else
{
ptr = ptr->nastepny;
}
}
}

void usun(INFO *info,int value){  // 1. 'tmp' to kiepska nazwa na parametr wywolania funkcji
    ELEMENT *ptr = info->glowa;
    ELEMENT *tmp = NULL;     // za to b. dobra nazwa na zmienna tymczasowa
   // tmp wskazuje na null przy pierwszym elemencie lub poprzedni element
 
    while(ptr){
       ELEMENT *next = ptr->nastepny; // zapamietac nastepny element
       if(ptr->wartosc == value){
          if(tmp){  // j. w. tmp wskazuje na null przy pierwszym elemencie lub poprzedni element
            tmp->nastepny = ptr->nastepny; // wiazanie poprzedniego elementu z nastepnym
          }else info->glowa = ptr->nastepny; // usuniecie pierwszego elementu: przesuniecie glowy na nastepny
          if( nfo->ogon == ptr ) nfo->ogon=tmp; // jesli trzeba usunac koniec
          delete (ptr);
       }else tmp = ptr;  // zapamietaj poprzedni element
       ptr = next;    // przypisac zapamietany nastepny element
    }
 }

Jezeli usuwasz jedyny element (tmp ma wartosc null, ptr->nastepny ma wartosc null i ptr==info->ogon):
next=ptr->nastepny (null)
info->glowa = ptr->nastepny (null)
info->ogon = tmp (null)
ptr=next

Jezeli usuwasz koncowy (ptr==info->ogon):
next=ptr->nastepny;
info->ogon = tmp (poprzedzajacy ptr lub null w przypadku jedynego elementu listy)
ptr=next

Jezeli usuwasz poczatkowy(tmp ma wartosc null):
next=ptr->nastepny
info->glowa = ptr->nastepny (nastepny lub null jesli jedyny)
ptr=next

jezeli usuwasz cos ze srodka listy (tmp!=null, ptr->nastepny!=null):
next=ptr->nastepny
ptr=next

jezeli nic nie usuwasz:
next=ptr->nastepny
tmp=ptr tylko wtedy zmieniasz poprzedni element.
ptr=next