Probleme mit der Zifferausgabe bei Verkettete Listen

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

struct element
   {
      int nummer;
      struct element *next;
   };


struct element *sort_hinzufuegen(struct element *first, int i)
{
    struct element *akt_el1, *akt_el2;

    if(first==NULL)
    {
        first=(struct element*) malloc(sizeof(struct element));
        first->nummer=i;
        first->next=NULL;

        return first;
    }

    else
    {
        akt_el1=first;

        while(akt_el1!=NULL  && akt_el1->nummer<i)
               akt_el1=akt_el1->next;

        if(akt_el1==NULL)
        {
            akt_el1=(struct element*) malloc(sizeof(struct element));
            akt_el1->nummer=i;
            akt_el1->next=NULL;
            return first;
        }
        else if(akt_el1==first)
        {
            first=(struct element*) malloc(sizeof(struct element));
            first->nummer=i;
            first->next=akt_el1;
            return first;
        }
        else
        {
            akt_el2=first;
            while(akt_el2->next!=akt_el1)
                akt_el2=akt_el2->next;

            akt_el1=(struct element*) malloc (sizeof(struct element));

           akt_el1->nummer=i;
            akt_el1->next=akt_el2->next;
            akt_el2->next=akt_el1;
            return first;
        }
    }
}

void ausgeben(struct element *first)
{
      while (first!=NULL)
      {
           printf("%i ", first->nummer);
           first=first->next;
      }
      printf("\n");
}


int main()
{
    struct element *first=NULL;

    first= sort_hinzufuegen(first, 4);
        first= sort_hinzufuegen(first, 6);
            first= sort_hinzufuegen(first, 1);
                first= sort_hinzufuegen(first, 4);
                    first= sort_hinzufuegen(first, 6);
                        first= sort_hinzufuegen(first, 20);
                            first= sort_hinzufuegen(first, 2);
                                first= sort_hinzufuegen(first, 55);
                                    first= sort_hinzufuegen(first, 3);

    ausgeben(first);

    return 0;
}



################################################################
Habe Probleme mit der Ausgabe von bestimmten Zahlen:
Er gibt in folgendem Beispiel zwar die Zahlen in richtiger Reihenfolge 
aus:

1  2  3  4  4

aber die folgenden Zahlen 6 6 30 55 werden nicht ausgegeben.

Es handelt sich bei folgendem Programm um eine sortierte Eingabe von 
Zahlen in eine Liste + Ausgabe der Liste.

Wieso werden die Zahlen 6 6 30 55  nicht ausgegeben???
################################################################
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Langsamer Modus Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Melden Danke 
Der Fehler dürfte hier liegen:

1
       if(akt_el1==NULL)

2
        {

3
            akt_el1=(struct element*) malloc(sizeof(struct element));

4
            akt_el1->nummer=i;

5
            akt_el1->next=NULL;

6
            return first;

7
        }


Du erzeugst hier ein neues Element, hängst das aber nie in die Liste 
ein.
Antwort Zitieren Bearbeiten Löschen Melden Danke
Gast 
> Der Fehler dürfte hier liegen:
>        if(akt_el1==NULL)
>         {
>             akt_el1=(struct element*) malloc(sizeof(struct element));
>             akt_el1->nummer=i;
>             akt_el1->next=NULL;
>             return first;
>         }
>
> Du erzeugst hier ein neues Element, hängst das aber nie in die Liste
> ein.

Versteh ich nicht ganz:
Das Element wird doch am Ende der Liste eingefügt und dann der NULL - 
Zeiger angefügt...

Wenn ich als erstes Element in der Liste 70 anfüge, dann werden alle 
ausgegeben. Das erste Element ist größer als alle anderen und es werden 
die Zahlen 0-70 ausgegeben. Warum? Sobald ich 71 eingebe wird es nicht 
mehr angefügt.
Antwort Zitieren Bearbeiten Löschen Melden Danke 
ja, so sieht es komplett aus:
1
#include <stdio.h>

2
#include <stdlib.h>

3


4
struct element

5
{

6
  int nummer;

7
  struct element *next;

8
};

9


10


11
struct element *sort_hinzufuegen(struct element *first, int i)

12
{

13
  struct element *akt_el1, *akt_el2;

14


15
  if(first==NULL)

16
  {

17
    first=(struct element*) malloc(sizeof(struct element));

18
    first->nummer=i;

19
    first->next=NULL;

20


21


22
    printf( "eingefügt first==NULL: %d; neue Liste:\n", i );

23
    ausgeben( first );

24


25
    return first;

26
  }

27


28
  else

29
  {

30
    akt_el1=first;

31
    akt_el2=first;

32


33
    while(akt_el1!=NULL  && akt_el1->nummer<i)

34
    {

35
      akt_el2 = akt_el1; // akt_el2 hinter akt_el1 herlaufen lassen

36
      akt_el1 = akt_el1->next;

37
    }

38


39
    if(akt_el1==NULL)

40
    {

41
      // Einfügen nach letztem Element

42
      akt_el1=(struct element*) malloc(sizeof(struct element));

43
      akt_el1->nummer=i;

44
      akt_el1->next=NULL;

45
      akt_el2->next = akt_el1; // ! hinter altem Ende einfügen

46
      printf( "eingefügt akt_el1==NULL: %d; neue Liste:\n", i );

47
      ausgeben( first );

48


49
      return first;

50
    }

51
    else if(akt_el1==first)

52
    {

53
      first=(struct element*) malloc(sizeof(struct element));

54
      first->nummer=i;

55
      first->next=akt_el1;

56
      printf( "eingefügt akt_el1==first: %d; neue Liste:\n", i );

57
      ausgeben( first );

58
      return first;

59
    }

60
    else

61
    {

62
      // kann weg, weil akt_el2 jetzt bereits oben hinter akt_el1 herläuft

63
      //akt_el2=first;

64
      //while(akt_el2->next!=akt_el1)

65
      //  akt_el2=akt_el2->next;

66


67
      akt_el1=(struct element*) malloc (sizeof(struct element));

68


69
      akt_el1->nummer=i;

70
      akt_el1->next=akt_el2->next;

71
      akt_el2->next=akt_el1;

72
      printf( "eingefügt else: %d; neue Liste:\n", i );

73
      ausgeben( first );

74
      return first;

75
    }

76
  }

77
}

78


79
void ausgeben(struct element *first)

80
{

81
  while (first!=NULL)

82
  {

83
    printf("%i ", first->nummer);

84
    first=first->next;

85
  }

86
  printf("\n");

87
}

88


89


90
int main()

91
{

92
  struct element *first=NULL;

93


94
  first= sort_hinzufuegen(first, 4);

95
  first= sort_hinzufuegen(first, 6);

96
  first= sort_hinzufuegen(first, 1);

97
  first= sort_hinzufuegen(first, 4);

98
  first= sort_hinzufuegen(first, 6);

99
  first= sort_hinzufuegen(first, 20);

100
  first= sort_hinzufuegen(first, 2);

101
  first= sort_hinzufuegen(first, 55);

102
  first= sort_hinzufuegen(first, 3);

103


104
  ausgeben(first);

105


106
  return 0;

107
}


Abgesehen davon, daß man es noch etwas vereinfachen könnte...
Antwort Zitieren Bearbeiten Löschen Melden Danke
Gast 
>Das Element wird doch am Ende der Liste eingefügt und dann der NULL -
>Zeiger angefügt...

Durch welche Anweisung genau wird denn das neue Element an das Ende der 
Liste eingefügt?
Antwort Zitieren Bearbeiten Löschen Melden Danke 
Bitte, als Zugabe noch eine etwas kompaktere Version:
1
#include <stdio.h>

2
#include <stdlib.h>

3


4
struct element

5
{

6
  int nummer;

7
  struct element *next;

8
};

9


10


11
void sort_hinzufuegen( struct element **p_first, int i )

12
{

13
  struct element *neu = (struct element*)malloc( sizeof(struct element) );

14


15
  if( !neu )

16
  {

17
    fprintf( stderr, "oioioi!\nkein Speicher mehr...\n" );

18
    exit( 1 );

19
  }

20


21
  neu->nummer = i;

22
  neu->next   = NULL;

23


24
  if( !*p_first )

25
  {

26
    // Liste bisher leer

27


28
    *p_first = neu;

29
  }

30
  else

31
  {

32
    // bereits mindestens ein Element vorhanden!

33


34
    // Kleine übergehen:

35
    while( *p_first && (*p_first)->nummer<i )

36
    {

37
      p_first = &(*p_first)->next;

38
    }

39


40
    // Jetzt hinter *p_first einhängen...

41


42
    // Falls es einen Nachfolger gibt, diesen an neu anhängen:

43
    neu->next = *p_first;

44
    // neues Element hinter letztem Vorgänger einklinken:

45
    *p_first = neu;

46
  }

47
}

48


49


50
void ausgeben( struct element *first )

51
{

52
  while (first!=NULL)

53
  {

54
    printf("%i ", first->nummer);

55
    first=first->next;

56
  }

57
  printf("\n");

58
}

59


60


61
int main()

62
{

63
  struct element *first=NULL;

64


65
  sort_hinzufuegen( &first,  4 );

66
  ausgeben( first );

67
  sort_hinzufuegen( &first,  6 );

68
  ausgeben( first );

69
  sort_hinzufuegen( &first,  1 );

70
  ausgeben( first );

71
  sort_hinzufuegen( &first,  4 );

72
  ausgeben( first );

73
  sort_hinzufuegen( &first,  6 );

74
  ausgeben( first );

75
  sort_hinzufuegen( &first, 20 );

76
  ausgeben( first );

77
  sort_hinzufuegen( &first,  2 );

78
  ausgeben( first );

79
  sort_hinzufuegen( &first, 55 );

80
  ausgeben( first );

81
  sort_hinzufuegen( &first,  3 );

82
  ausgeben(first);

83


84
  return 0;

85
}
Antwort Zitieren Bearbeiten Löschen Melden Danke
Thread beobachten

Antwort schreiben

Eine eigene Frage? Dieser Thread ist über 15 Jahre alt. Stell sie in einem eigenen Thread – dort lesen mehr Leute mit, und sie wird öfter und schneller beantwortet.

Neuen Thread starten

Eine Lösung, Ergänzung oder Rückmeldung zu diesem Thread? Dann antworte hier.

Formatierung
  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] – Link zu einem Artikel
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen

Mehr zur Formatierung

Längeren Sourcecode als Anhang, nicht in den Text. JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF. Siehe Bildformate.

Dein Name und deine E-Mail-Adresse

Schon registriert? Anmelden

Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.