typedef struct adresse_e {                                    // Listenelement
          char               name   [ NAMLEN_MAX];                // Nutzdaten
          char               vorname[VNAMLEN_MAX];
          char               telNr  [  TNLEN_MAX];
          struct adresse_e * next;                     // Zeiger fuer Liste
          struct adresse_e * prev;
       } adresse_t;

typedef adresse_t* ple_t;


// Ausketten : Listenelement aus der Liste ausketten
// *************************************************
// input : PtrFirst    Wurzelzeiger der Liste
//         PtrSet      Zeiger auf auszukettendes LE
// output: Returnwert  Wurzelzeiger nach dem Ausketten
// ***************************************************************************
ple_t Ausketten( ple_t PtrFirst, ple_t PtrSet ) {
  enum { ungueltig, ausketten}  Kettfall;     // fuer einfache Fehlererkennung
  if( PtrFirst== NULL || PtrSet== NULL ) Kettfall = ungueltig;
    else Kettfall = ausketten;
  switch( Kettfall ) {
    case ungueltig:
      break;
    case ausketten:
      if( PtrSet == PtrFirst ) {                            // 1. LE ausketten
        PtrFirst = PtrSet->PtrNext;             // neues 1. LE -> Wurzelzeiger
        if( PtrSet->PtrNext != NULL ) PtrFirst->PtrPrev = NULL;     // kein VG
        }
      else {                                      // nicht das 1. LE ausketten
        PtrSet->PtrPrev->PtrNext = PtrSet->PtrNext;     // VG erhaelt neuen NF
        if( PtrSet->PtrNext != NULL)                    // NF erhaelt neuen VG
          PtrSet->PtrNext->PtrPrev = PtrSet->PtrPrev;
        }
      break;
  } // switch( Kettfall ) { ...
  return PtrFirst;
} // Ausketten()


// Einketten : Listenelement in Liste einketten
// ***************************************************************************
// input : PtrFirst    Wurzelzeiger der Liste
//         PtrVor      Listenposition fuer Vorketten
//         PtrNach     Listenposition fuerNachketten
//         PtrSet      zeiger auf eizuketttendes Listenelement
// output: Returnwert  Wurzelzeiger nach dem Einketten
//
// Die moeglichen Aufrufkombinationen fuer PtrVor und PtrNach koennen dem
// Vorlesungsumdruck Prog. I oder der Fehlererkennung entnommen werden
// ***************************************************************************
ple_t Einketten(ple_t PtrFirst, ple_t PtrVor, ple_t PtrNach, ple_t PtrSet) {
  // Aufruf-Bedingungen und Fehler erkennen
  enum { ungueltig, neueliste, vorketten, nachketten, anhaengen} KF;

  if       ( PtrSet   == NULL                         ) KF = ungueltig;
    else if( PtrFirst == NULL                         ) KF = neueliste;
    else if( PtrSet   == PtrVor || PtrSet  == PtrNach ) KF = ungueltig;
    else if( PtrVor   != NULL   && PtrNach == NULL    ) KF = vorketten;
    else if( PtrVor   == NULL   && PtrNach != NULL    ) KF = nachketten;
    else if( PtrVor   == NULL   && PtrNach == NULL    ) KF = anhaengen;
    else                                                KF = ungueltig;
  switch( KF ) {                                          // Element einketten
    case ungueltig:
      break;
    case neueliste:
      PtrFirst = PtrSet; PtrFirst->PtrPrev = NULL; PtrFirst->PtrNext= NULL;
      break;
    case vorketten:
      PtrSet->PtrPrev = PtrVor->PtrPrev; PtrSet->PtrNext = PtrVor;
      if( PtrSet->PtrPrev == NULL ) PtrFirst = PtrSet;
        else PtrSet->PtrPrev->PtrNext = PtrSet;
      PtrVor->PtrPrev = PtrSet;
      break;
    case nachketten:
      PtrSet->PtrPrev  = PtrNach;  PtrSet->PtrNext = PtrNach->PtrNext;
      PtrNach->PtrNext = PtrSet;
      if( PtrSet->PtrNext!= NULL) PtrSet->PtrNext->PtrPrev = PtrSet;
      break;
    case anhaengen:
      for(PtrNach=PtrFirst;PtrNach->PtrNext!=NULL;PtrNach=PtrNach->PtrNext);
      PtrSet->PtrNext  = NULL;    PtrSet->PtrPrev = PtrNach;
      PtrNach->PtrNext = PtrSet;
      break;
  } // switch( KF ) { ...
  return PtrFirst;
} // Einketten()


// ListeLoeschen : bestehende Liste loeschen
// ***************************************************************************
// input : PtrFirst    Wurzelzeiger der Liste
// output: Returnwert  Konstante NULL fuer Wurzelzeiger
// ***************************************************************************
ple_t ListeLoeschen( ple_t PtrFirst ) {
  ple_t PtrAkt = PtrFirst, PtrDel;              // Hilfszeiger fuer Loeschen
  while( PtrAkt!= NULL ) {
    PtrDel = PtrAkt;  PtrAkt = PtrAkt->PtrNext;  free(PtrDel);
  } // while
  return NULL;
} // ListeLoeschen()