Lista podwieszana

Witam, mam do napisania program na zaliczenie. Dało by się to zrobić jedną listą, ale wtedy bedzie to strasznie naciągane i niefajne. Wpadłem na pomysł, żeby rozwiązać to listą podwieszaną. Lista główna to lista osób (nicków). Od każdego nicku ma się rozgałęziać lista czasów które dana osoba osiąga (chodzi o czasy ułożenia kostki rubika :P no nie ważne). Póki co mam działająca funkcje dodawania czasów, nie wiem jak połączyć ją z listą główną. Jak przekazać ten wskaźnik z listy osób do listy czasów, czyli mówiąc krótko jak je połączyć. Ma być w C, nie może być w C++ :)

Struktury są takie:

struct OSOBA
{
	double nick;
	struct OSOBA *nast;
	struct CZASY *pierwszy;
};

struct CZASY
{
	double lczas;
	struct CZASY *nast;
}; 

struct CZASY* DodajCzas(struct CZASY *glowa, double x)
{
struct CZASY *nowy = (struct CZASY*)malloc(sizeof(struct CZASY));
struct CZASY *tmp;

   

    tmp = glowa;
    
    nowy->lczas = x;
     
	 if (glowa == NULL)
     {
	   nowy->nast = NULL;	
	   glowa = nowy;	
	 }
	 else
	 {
	 
	 
	 while (glowa->nast != NULL)
	 {
		glowa = glowa->nast;	
	 }
	 
	 glowa->nast = nowy;   	                     
     nowy->nast = NULL;
     glowa = tmp;
 
	}  
 return glowa; 
}
 

 
struct OSOBA* DodajOsobe(struct CZASY *glowa,struct OSOBA *glowa2, char nick[10])
{
struct OSOBA *nowy = (struct OSOBA*)malloc(sizeof(struct OSOBA));
struct OSOBA *tmp;



    tmp = glowa2;
    nowy->nick = nick;
     
	 if (glowa2 == NULL)
     {
	   nowy->nast = NULL;	
	   glowa2 = nowy;	
	 }
	 else
	 {
	 
	 
	 while (glowa2->nast != NULL)
	 {
		glowa2 = glowa2->nast;	
	 }
	 
	 glowa2->nast = nowy;   	                     
     nowy->nast = NULL;
     glowa2 = tmp;
 
	}  
	
	nowy->pierwszy = glowa;
  	
 return glowa2; 
}

P.S. Wiem, że ten char nie zadziała, ale dałem poki co zeby było wiadomo że to ma być nick.

W zasadzie oprócz tego, że dodawanie jest skopane to jest prawie gotowe. Głowę listę musisz przekazywać przez podwójny wskaźnik aby dało się ją nadpisać. A zresztą zobacz:

struct ElementListy
{
    struct ElementListy *nast;
};

void ListaDodaj(struct ElementListy **lista, ElementListy *element)
{
    while (*lista != NULL) lista = &((*lista)->nast);
    *lista = element;
}

struct CZAS
{
    ElementListy element_listy; // to pole musi być jako pierwsze!

    double lczas;
}; 

struct OSOBA
{
    ElementListy element_listy; // to pole musi być jako pierwsze!

    char *nick;
    CZAS *czasy;
};
 
struct OSOBA *DodajOsobe(OSOBA **lista, char *nick)
{
    OSOBA *ret = (OSOBA*)calloc(sizeof(OSOBA), 1);
    ret->nick = strdup(nick);
    ListaDodaj((struct ElementListy**)lista, ret);
    return ret;
}

struct CZAS *DodajCzas(OSOBA *osoba, double czas)
{
    CZAS *ret = (CZAS*)calloc(sizeof(CZAS), 1);
    ListaDodaj((struct ElementListy**)&osoba->czasy, ret);
    return ret;
}

//...
struct OSOBA *lista_osob = NULL;
struct OSOBA *osoba = DodajOsobe(&lista_osob, "anonymous");
struct CZAS *czas = DodajCzas(osoba, 666);

1. Po kiego dodajesz na koniec listy, przynajmniej przy czasach NIE MA znaczenia w jakiej kolejności występowali, dodaj na początek listy, oszczędzisz pętli po całej liście przy każdym dodawaniu.
2. Jeżeli do listy musisz koniecznie dodawać na koniec, to dodaj strukturę GRUPA zawierającą wskaźniki OSOBA *pierwszy,*ostatni; i zamiast pętli po wszystkim elementam listy przy dodawaniu masz tylko jeden dodatkowy wskaźnik.

Czyli generalnie coś w ten deseń:

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

struct GRUPA
  {
   struct OSOBA *pierwszy;
   struct OSOBA *ostatni;
  };

struct OSOBA
  {
   char *nick;
   struct OSOBA *nast;
   struct CZASY *pierwszy;
  };

struct CZASY
  {
   double lczas;
   struct CZASY *nast;
  };

struct OSOBA *DodajOsobe(struct GRUPA *L,const char *nick)
  {
   struct OSOBA *nowy=(struct OSOBA*)malloc(sizeof(struct OSOBA));
   nowy->nick=strdup(nick);
   nowy->nast=NULL;
   nowy->pierwszy=NULL;
   if(L->ostatni) L->ostatni->nast=nowy; else L->pierwszy=nowy;
   L->ostatni=nowy;
   return nowy;
  }

struct CZASY *DodajCzasy(struct OSOBA *L,double lczas)
  {
   struct CZASY *nowy = (struct CZASY*)malloc(sizeof(struct CZASY));
   nowy->lczas=lczas;
   nowy->nast=L->pierwszy;
   L->pierwszy=nowy;
   return nowy;
  }

void Wyswietl(struct CZASY *L)
  {
   printf("%.1lf",L->lczas);
  }
  
void Wyswietl(struct OSOBA *L)
  {
   printf("%s {",L->nick);
   for(struct CZASY *i=L->pierwszy;i;i=i->nast)
     {
      if(i!=L->pierwszy) printf(", ");
      Wyswietl(i);
     }
   printf("}");
  }
  
void Wyswietl(struct GRUPA *L)
  {
   for(struct OSOBA *i=L->pierwszy;i;i=i->nast)
     {
      Wyswietl(i);
      printf("\n");
     }
  }

int main()
  {
   struct GRUPA G={0,0};
   struct OSOBA *A;
   A=DodajOsobe(&G,"Dock");
   DodajCzasy(A,1); DodajCzasy(A,2); DodajCzasy(A,3); DodajCzasy(A,4); 
   A=DodajOsobe(&G,"Fast");
   DodajCzasy(A,5); DodajCzasy(A,6); DodajCzasy(A,7);
   A=DodajOsobe(&G,"Seth");
   DodajCzasy(A,8); DodajCzasy(A,9);
   
   Wyswietl(&G);

   getchar();
   return 0;
  }