Verkettete Listen in Ansi C

Daniel Gast #999444
Lesenswert?
• ▲
▼ 
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
1
#include <stdio.h>

2


3
 struct Liste

4
   {char name;             //Daten

5
   struct Liste *next;     //Zeiger auf naechstes Element

6
   };

7


8
 typedef Liste* Pliste;     // Zeigertype definieren

9


10


11
void neu(Pliste);

12
 void init(Pliste & );

13


14
 void main ()

15


16
 {

17
    

18
  Pliste *akt=NULL

19
    

20
init(first);

21
  

22


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

24
        

25
 }

26


27
 void init (Pliste &p)    // Unterprogramm Init

28
   { p = NULL;

29
   }

30
void  neu(Pliste)

31
{

32


33
  Pliste *akt;

34
  akt=first;

35
  while(akt->next!=NULL)

36
  {

37
    akt=akt->;

38
    new (Pliste*)malloc(sizeof struct(Pliste);

39
  }

40
  akt->next=new;

41
    new->next=NULL;

42


43


44
}
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Stefan B. Persönliche Seite #999476
Lesenswert?
• ▲
▼ 
Der Code strotzt vor Syntaxfehlern. Das kann so nicht gehen.

1
#include <stdio.h>

2


3
struct Liste

4
{

5
  char name;               // Daten

6
  struct Liste *next;      // Zeiger auf naechstes Element

7
};

8


9
typedef Liste* Pliste;     // Zeigertype definieren

10


11
void neu(Pliste);

12
void init(Pliste & );

13
//               ^ häh?

14


15
void main ()

16
{

17
  Pliste * akt = NULL

18
  //                 ^ häh?

19
   

20
  init(first);

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

22
}

23


24
void init (Pliste &p)    // Unterprogramm Init

25
//                ^ häh?

26
{ 

27
  p = NULL;

28
}

29


30
void  neu(Pliste)

31
//              ^ häh?

32
{

33
  Pliste *akt;

34


35
  akt = first;

36
// ^      ^   häh? 

37


38
  while(akt->next != NULL)

39
  {

40
    akt = akt->;

41
    //         ^ häh?

42
    new (Pliste*) malloc(sizeof struct(Pliste);

43
//  ^ häh?                     ^              ^  

44
  }

45


46
  akt->next = new;

47
  new->next = NULL;

48
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Stefan B. Persönliche Seite #999525
Lesenswert?
• ▲
▼ 
1
#include <stdio.h>

2


3
struct Liste

4
{

5
  char name;               // Daten

6
  struct Liste * next;     // Zeiger auf naechstes Element

7
};

8


9
typedef struct Liste * Pliste;    // Zeigertype definieren

10


11
void Element_anhaengen(Pliste, char);

12
Pliste Liste_anlegen(void);

13
Pliste Liste_zerstoeren(Pliste);

14


15


16
int main(void) // ANSI C

17
{

18
  Pliste top;

19


20
  top = Liste_anlegen();

21
  Element_anhaengen(top, 'a');                

22
  top = Liste_zerstoeren(top);

23
}

24


25
Pliste Liste_anlegen(void)

26
{ 

27
  // Listenanfang = Leeres Element vom Typ struct Liste anlegen

28
  p = (Pliste) malloc(sizeof(struct Liste));

29


30
  if (p != NULL)

31
  {

32
    // Ausnullen (macht malloc() nicht)

33
    p->daten = 0;

34
    p->next = NULL;

35
  }

36


37
  // Listenanfang merken, d.h. zurückgeben

38
  return p;

39
}

40


41
void Element_anhaengen(Pliste akt, char daten)

42
{

43
  if (akt == NULL)

44
    return;

45


46
  // Leeres Element am Ende suchen

47
  while(akt->next != NULL)

48
  {

49
    akt = akt->next;

50
  }

51


52
  // Daten in letztes, leere Element eintragen

53
  akt->daten = daten;

54


55
  // neues leeres Element anhängen

56
  akt->next = (Pliste) malloc(sizeof(struct Liste));

57
  akt = akt->next;

58


59
  if (akt != NULL)

60
  {

61
    // Ausnullen (macht malloc() nicht)

62
    akt->daten = 0;

63
    akt->next = NULL;

64
  }

65
}

66


67
Pliste Liste_zerstoeren(Pliste akt)

68
{

69
  while(akt != NULL)

70
  {

71
    // Zeiger auf ggf. nächstes Element merken

72
    Pliste next = akt->next;

73


74
    // aktuelles Element ausnullen 

75
    akt->daten = 0;

76
    akt->next = NULL;

77


78
    // und freigeben

79
    free(akt);

80


81
    // und wiederholen mit nächstem Element

82
    akt = next;

83
  }

84


85
  return akt;

86
}


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!
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren