Probleme mit der Zifferausgabe bei Verkettete Listen

Saskia Gruber Gast #2018175
Lesenswert?
• ▲
▼ 
#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 Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Saskia Gruber Gast #2018258
Lesenswert?
• ▲
▼ 
> 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 Beitrag melden
Klaus W. #2018259
Lesenswert?
• ▲
▼ 
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 Beitrag melden
Klaus W. #2018336
Lesenswert?
• ▲
▼ 
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 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