Verkettete Listen in Ansi C

[Daniel (Gast)]

Hallo Leute ich hab ein Problem...

Ich will Elemente genauer gesagt char elemente in eine einfach 
verkettete Liste einfügen um sie anschließend zu suchen zu löschen etc. 
aber das ist nicht das Problem.

Ich wollte es zuerst nur mit einem Elementr versuchen aber irgendwie 
haperts da...

mein code

#include <stdio.h>

 struct Liste
   {char name;             //Daten
   struct Liste *next;     //Zeiger auf naechstes Element
   };

 typedef Liste* Pliste;     // Zeigertype definieren


void neu(Pliste);
 void init(Pliste & );

 void main ()

 {
    
  Pliste *akt=NULL
    
init(first);
  

       printf("Geben sie einen Namen ein:\n");
        
 }

 void init (Pliste &p)    // Unterprogramm Init
   { p = NULL;
   }
void  neu(Pliste)
{

  Pliste *akt;
  akt=first;
  while(akt->next!=NULL)
  {
    akt=akt->;
    new (Pliste*)malloc(sizeof struct(Pliste);
  }
  akt->next=new;
    new->next=NULL;


}

[Stefan B. (stefan)]

Der Code strotzt vor Syntaxfehlern. Das kann so nicht gehen.

#include <stdio.h>

struct Liste
{
  char name;               // Daten
  struct Liste *next;      // Zeiger auf naechstes Element
};

typedef Liste* Pliste;     // Zeigertype definieren

void neu(Pliste);
void init(Pliste & );
//               ^ häh?

void main ()
{
  Pliste * akt = NULL
  //                 ^ häh?
   
  init(first);
  printf("Geben sie einen Namen ein:\n");
}

void init (Pliste &p)    // Unterprogramm Init
//                ^ häh?
{ 
  p = NULL;
}

void  neu(Pliste)
//              ^ häh?
{
  Pliste *akt;

  akt = first;
// ^      ^   häh? 

  while(akt->next != NULL)
  {
    akt = akt->;
    //         ^ häh?
    new (Pliste*) malloc(sizeof struct(Pliste);
//  ^ häh?                     ^              ^  
  }

  akt->next = new;
  new->next = NULL;
}

[Daniel (Gast)]

Ja das hab ich mir schon fast gedacht wäre ja zu schön :) aber was genau 
ist hier der Fehler mach ich die pointer falsch?

[ich (Gast)]

häh

[Stefan B. (stefan)]

#include <stdio.h>

struct Liste
{
  char name;               // Daten
  struct Liste * next;     // Zeiger auf naechstes Element
};

typedef struct Liste * Pliste;    // Zeigertype definieren

void Element_anhaengen(Pliste, char);
Pliste Liste_anlegen(void);
Pliste Liste_zerstoeren(Pliste);


int main(void) // ANSI C
{
  Pliste top;

  top = Liste_anlegen();
  Element_anhaengen(top, 'a');                
  top = Liste_zerstoeren(top);
}

Pliste Liste_anlegen(void)
{ 
  // Listenanfang = Leeres Element vom Typ struct Liste anlegen
  p = (Pliste) malloc(sizeof(struct Liste));

  if (p != NULL)
  {
    // Ausnullen (macht malloc() nicht)
    p->daten = 0;
    p->next = NULL;
  }

  // Listenanfang merken, d.h. zurückgeben
  return p;
}

void Element_anhaengen(Pliste akt, char daten)
{
  if (akt == NULL)
    return;

  // Leeres Element am Ende suchen
  while(akt->next != NULL)
  {
    akt = akt->next;
  }

  // Daten in letztes, leere Element eintragen
  akt->daten = daten;

  // neues leeres Element anhängen
  akt->next = (Pliste) malloc(sizeof(struct Liste));
  akt = akt->next;

  if (akt != NULL)
  {
    // Ausnullen (macht malloc() nicht)
    akt->daten = 0;
    akt->next = NULL;
  }
}

Pliste Liste_zerstoeren(Pliste akt)
{
  while(akt != NULL)
  {
    // Zeiger auf ggf. nächstes Element merken
    Pliste next = akt->next;

    // aktuelles Element ausnullen 
    akt->daten = 0;
    akt->next = NULL;

    // und freigeben
    free(akt);

    // und wiederholen mit nächstem Element
    akt = next;
  }

  return akt;
}

Die Liste wird vom Anfang in Richtung Ende freigegeben, d.h. 
widernatürlich im Bezug zum Anlegevorgang (Man sägt nicht am Ast auf dem 
man sitzt).

Man könnte das beheben, in dem man eine doppelt verkettete, d.h. auch 
rückwärtz verlinkte Liste anlegt oder in dem man mit Rekursion arbeitet.

Code ist ungetestet, lediglich hingeschrieben!

[Stefan B. (stefan)]

Fehlerkorrektur:

Pliste Liste_anlegen(void)
{ 
  Pliste p;  // !!! 

  // Listenanfang = Leeres Element vom Typ struct Liste anlegen
  p = (Pliste) malloc(sizeof(struct Liste));

[Oliver N. (neufranke)]

Ich hätte da noch ein altes Vorlesungsscript mit sogar zweifach 
verketteten Listen als Baum.