Problem mit Aufruf des Programms

[sasch00]

Moin !

Ich habe zwei Funktionen geschrieben, wobei die eine lediglich einer liste einen Kopfzeiger hinzufügt und entweder die ganze Liste oder nur eine Teilliste sortiert.
Die eigentliche Sortierung macht das andere Unterprogramm. Die Sortierung funktioniert auch.

Jetzt bekomme ich allerdings beim kompilieren die Fehlermeldung:

Unresolved external

und ich finde einfach meinen Fehler nicht.

Könnt ihr mir da weiterhelfen ?

Hier mein bisheriger Quellcode:

typedef struct listnode
{
   int key;
   char *ptext;
   struct listnode *pnext;
} Listnode;

void listmsorti (int n, Listnode *phead);
Listnode *listmergesort (int n, Listnode *pstart);

/* Hauptprogramm */

int main()
{
   Listnode *pstart, *ptemp, *pv;
   int i;

   /* Anlegen des ersten Knotens */
   pstart = (Listnode *) malloc (sizeof (Listnode));
   if (pstart != NULL)
   {
      pstart -> key = rand();
      pstart -> pnext = NULL;
   }
   pv = pstart;
   /* Anlegen weiterer Knoten */
     for (i = 1; i <= 10; i++){
        ptemp = (Listnode *) malloc (sizeof (Listnode));
         if (ptemp != NULL)
         {
            ptemp -> key = rand();
            ptemp -> pnext = NULL;
            pv -> pnext = ptemp;
            pv = ptemp;
         }
      }
   /* Ausschreiben der Liste vor Sortierung*/
   ptemp = pstart;
   printf("Liste vor Sortierung:\n");
   i = 0;
   while (ptemp != NULL)
   {
      printf("Listenknoten %d: key = %d\n", i, ptemp -> key);
      ptemp = ptemp -> pnext;
      i++;
   }

   printf("\n\n");

   /* Aufruf von listmergesort */
   pstart = listmergesort (-1, pstart);

   /* Ausschreiben der Liste nach Sortierung*/
   ptemp = pstart -> pnext;
   printf("\n\n");
   printf("Liste nach Sortierung:\n");
   i = 0;
   while (ptemp != NULL)
   {
      printf("Listenknoten %d: key = %d\n", i, ptemp -> key);
      ptemp = ptemp -> pnext;
      i++;
   }
   getch();
   return 0;
}

/******************************************************************
* Name: lismsorti                                                  *
* Funktion: Sortierrung einer Verketteten Liste                    *
*           nach der Schlüsselkomponente Key                       *
* Prototyp: void listmsorti (int n, Listnode *phead);              *
* Parameter:                                                       *
*        n: (E) Anzahl der Listenelemente                          *
*   *phead: (E) Kopfzeiger, der auf das erste Listenelement zeigt  *
*******************************************************************/

void listmsorti (int n, Listnode *phead)
{
   Listnode  *pheadl, *pheadr, *ptemp;
   int i, nl, nr, sortl, sortr;

   nl = n/2;
   nr = n - nl;

   if (n > 1)   /* Endebedingung der Rekursion */
   {

      pheadl = phead;   //pheadl zeigt auf Anfang des linken Teils
      pheadr = pheadl;

      // pheadr auf das letzte Element des linken Teils zeigen lassen

      /* Aufruf der Rekursion */
      listmsorti (nl, pheadl);    /* Rekursiv linker Teil */
      for (i = 0; i < nl; i++)
      {
         pheadr = pheadr -> pnext;
      }
      listmsorti (nr, pheadr);     /* Rekursiv rechter Teil */

      /* Mischen */
      sortl = 0;
      sortr = 0;

      while (sortl < (nl+1) && sortr < nr)
      {
         if (pheadl -> pnext -> key <= pheadr -> pnext -> key)    // Einfaches Fortschreiten in pheadl
         {
            sortl++;
            pheadl = pheadl -> pnext;
         }
         else    // pheadr ->pnext in pheadl-> einfuegen
         {
            ptemp = pheadr -> pnext -> pnext; /* Nachfolge Knoten von pheadr sichern*/
            pheadr -> pnext -> pnext = pheadl -> pnext;
            pheadl -> pnext = pheadr -> pnext;
            pheadr -> pnext = ptemp;
            sortr++;
         }
      }
   }
}

/******************************************************************
* Name: listmergesort                                             *
* Funktion: Schnittstellenadapter zwischen Anwendungsprogramm     *
*           und der Funktion listmsorti                           *
* Prototyp: Listnode *listmergesort (int n, Listnode *pstart)     *
* Parameter:                                                      *
*        n: (E) n = -1: gesammte Liste wird sortiert              *
*               n = >1: es werden n Listenelemente sortiert       *
*               ist n größer als Anzahl der Listenelemente,       *
*               gesammte Liste wird sortiert                      *
*   pstart: (E) Adresse des ersten Listenelements                 *
*                                                                 *
* Funktionswert: aktualisierte Startzeiger                        *
*                                                                 *
******************************************************************/

Listnode *lismergesort (int n, Listnode *pstart)
{
   Listnode *phead, *ptemp;
   int nliste;

   if (pstart != NULL)
   {
      /* Länge der Liste bestimmen */
      ptemp = pstart;
      nliste = 0;
      while (ptemp != NULL)
      {
         nliste++;
         ptemp = ptemp -> pnext;
      }
      printf ("Die Liste enthaelt %d Elemente.\n", nliste);
      printf("\n\n");

      /* Hinzufuegen des Kopfzeigers */
      phead = (Listnode *) malloc (sizeof (Listnode));
      if (phead != NULL)
         phead -> pnext = pstart;

      /* Ausfuehren der Sortierung */
      if (n == -1)
         listmsorti (nliste, phead);
      else if (n > nliste)
         listmsorti (nliste, phead);
      else
         listmsorti (n, phead);
   }
   return phead;
}

[sasch00]

Hab meinen Fehler gefunden....Dieser blöde Rechtschtschreibfehler