Probleme mit der Zifferausgabe bei Verkettete Listen

[Saskia Gruber (Gast)]

#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???
################################################################

[Rolf M. (rmagnus)]

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.

[Saskia Gruber (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.

[Klaus W. (mfgkw)]

ja, so sieht es komplett aus:

#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;


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

    return first;
  }

  else
  {
    akt_el1=first;
    akt_el2=first;

    while(akt_el1!=NULL  && akt_el1->nummer<i)
    {
      akt_el2 = akt_el1; // akt_el2 hinter akt_el1 herlaufen lassen
      akt_el1 = akt_el1->next;
    }

    if(akt_el1==NULL)
    {
      // Einfügen nach letztem Element
      akt_el1=(struct element*) malloc(sizeof(struct element));
      akt_el1->nummer=i;
      akt_el1->next=NULL;
      akt_el2->next = akt_el1; // ! hinter altem Ende einfügen
      printf( "eingefügt akt_el1==NULL: %d; neue Liste:\n", i );
      ausgeben( first );

      return first;
    }
    else if(akt_el1==first)
    {
      first=(struct element*) malloc(sizeof(struct element));
      first->nummer=i;
      first->next=akt_el1;
      printf( "eingefügt akt_el1==first: %d; neue Liste:\n", i );
      ausgeben( first );
      return first;
    }
    else
    {
      // kann weg, weil akt_el2 jetzt bereits oben hinter akt_el1 herläuft
      //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;
      printf( "eingefügt else: %d; neue Liste:\n", i );
      ausgeben( first );
      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;
}

Abgesehen davon, daß man es noch etwas vereinfachen könnte...

[Huch (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?

[Saskia Gruber (Gast)]

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


Dankeschön für die verständliche Erläuterung

[Klaus W. (mfgkw)]

Bitte, als Zugabe noch eine etwas kompaktere Version:

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

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


void sort_hinzufuegen( struct element **p_first, int i )
{
  struct element *neu = (struct element*)malloc( sizeof(struct element) );

  if( !neu )
  {
    fprintf( stderr, "oioioi!\nkein Speicher mehr...\n" );
    exit( 1 );
  }

  neu->nummer = i;
  neu->next   = NULL;

  if( !*p_first )
  {
    // Liste bisher leer

    *p_first = neu;
  }
  else
  {
    // bereits mindestens ein Element vorhanden!

    // Kleine übergehen:
    while( *p_first && (*p_first)->nummer<i )
    {
      p_first = &(*p_first)->next;
    }

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

    // Falls es einen Nachfolger gibt, diesen an neu anhängen:
    neu->next = *p_first;
    // neues Element hinter letztem Vorgänger einklinken:
    *p_first = neu;
  }
}


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


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

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

  return 0;
}