einfach verkettete Liste

Hallo,

das folgende Programm stammt angeblich aus einem Einstellungstest. Nun ging es darum ein oder mehrere Fehler darin zu finden. Ich markiere einfach mal die Funktionen in dehnen die Fehler stecken sollen mit //Fehler. Vielleicht kann mir einer sagen was konkret an diesen Funktionen falsch sein soll. Des weiteren ist mir die Zeile typedef struct _NODE NODE, *PNODE; nicht ganz klar. Für ne kurze Erklärung dieser Zeile wäre ich dankbar.

also vorab schonmal vielen Danke

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

/*
Die folgende Deklaration repraesentiert Elemente einer
einfach verketteten Liste.
*/

  typedef struct _NODE NODE, *PNODE;     // Fehler
  struct _NODE {                         // Fehler
    int Value;
    PNODE NextNode;
  };

/*
Eine iterative C-Funktion i_anzelem, welche die Anzahl der in
einer Liste enthaltenen Elemente ermittelt.
Die Funktion i_anzelem liefert einen int-Wert zurueck.
i_anzelem erhaelt als Parameter einen Zeiger auf den Listenanfang.
*/

  int i_anzelem(PNODE FirstNodeInList)
  {
    int anz = 0;

    while(FirstNodeInList != NULL) {
      anz++;
      FirstNodeInList = FirstNodeInList->NextNode;
    }

    return anz;
  }

/*
Eine zu i_anzelem aequivalente rekursive C-Funktion r_anzelem,
welche die Anzahl der in einer Liste enthaltenen Elemente ermittelt.
r_anzelem darf natuerlich keine Schleife verwenden.
*/

  int r_anzelem(PNODE FirstNodeInList)
  {
    if(FirstNodeInList == NULL)
      return 0;
    else
      return 1 + r_anzelem(FirstNodeInList->NextNode);
  }

void
add_front(PNODE *FirstNodeInList, int Key)
{
  PNODE tmp = (PNODE)malloc(sizeof(NODE));

  if (tmp == NULL)
    perror("out of memory");
  tmp->Value = Key;
  tmp->NextNode = *FirstNodeInList;
  *FirstNodeInList = tmp;
}

void
delete_front(PNODE *FirstNodeInList)
{
  PNODE tmp;

  if (FirstNodeInList == NULL)
    perror("list is empty");
  else {
    tmp = *FirstNodeInList;
    *FirstNodeInList = (*FirstNodeInList)->NextNode;
    free((void*)tmp);
  }
}

void
print_list(PNODE FirstNodeInList)
{
  while(FirstNodeInList != NULL)
  {
    printf("%d\t", FirstNodeInList->Value);
    FirstNodeInList = FirstNodeInList->NextNode;
  }
  printf("\n");
}

PNODE
NewNode(int Value)
{
  PNODE tmp;

  tmp = (PNODE)malloc(sizeof(NODE));
  if (tmp == NULL)
    perror("out of memory");
  tmp->Value = Value;
  tmp->NextNode = NULL;

  return tmp;
}

PNODE                                      // Fehler
InsertNodeInSortedSinglyLinkedList(                
  PNODE FirstNodeInList,
  PNODE NewNode)
{
  PNODE NodeInList = FirstNodeInList;
  PNODE PreviousNode = NULL;

  while(NodeInList->Value <= NewNode->Value){
    PreviousNode = NodeInList;
    NodeInList = NodeInList->NextNode;
  }

  PreviousNode->NextNode = NewNode;
  NewNode->NextNode = NodeInList;

  return FirstNodeInList;
}

int
main()
{
  PNODE list = NULL;

  printf("i_anzelem(NULL) == %d\n", i_anzelem(list));
  printf("r_anzelem(NULL) == %d\n", r_anzelem(list));

  add_front(&list, 5);
  add_front(&list, 4);
  add_front(&list, 3);
  add_front(&list, 2);
  add_front(&list, 1);
  print_list(list);

  printf("i_anzelem(list) == %d\n", i_anzelem(list));
  printf("r_anzelem(list) == %d\n", r_anzelem(list));

  delete_front(&list);
  delete_front(&list);
  print_list(list);
  printf("i_anzelem(list) == %d\n", i_anzelem(list));
  printf("r_anzelem(list) == %d\n", r_anzelem(list));

  list = NULL;
  list = InsertNodeInSortedSinglyLinkedList(list, NewNode(50));
  print_list(list);
  list = InsertNodeInSortedSinglyLinkedList(list, NewNode(30));
  print_list(list);
  list = InsertNodeInSortedSinglyLinkedList(list, NewNode(40));
  print_list(list);
  list = InsertNodeInSortedSinglyLinkedList(list, NewNode(45));
  print_list(list);
  list = InsertNodeInSortedSinglyLinkedList(list, NewNode(40));
  print_list(list);
  list = InsertNodeInSortedSinglyLinkedList(list, NewNode(60));
  print_list(list);
  list = InsertNodeInSortedSinglyLinkedList(list, NewNode(3));
  print_list(list);

  return 0;
}

borg

typedef struct _NODE NODE, *PNODE;

ich nehm an hier ist gemeint:

typedef struct _NODE NODE;
typedef struct *_NODE PNODE;

...
  PNODE PreviousNode = NULL;

  while(NodeInList->Value <= NewNode->Value){
    PreviousNode = NodeInList;
    NodeInList = NodeInList->NextNode;
  }

  PreviousNode->NextNode = NewNode;
...

angenommen das erste element in der liste ist kleiner als das neue element, dann geht er in die schleife nicht rein.
macht dann also:

...
  PNODE PreviousNode = NULL;
  PreviousNode->NextNode = NewNode;
...

und das hat undefiniertes verhalten.