Wie kann ich eine doppelte Elementeneingabe in die sortierte Liste verhindern ?



  • Hallo zusammen,

    Diese Funktion fügt INT Elemente sortiert in eine Liste ein. Jetzt muss ich aber nur noch kucken, das doppelte Elemente nicht eingefügt werden können und ne Fehlermeldung kommt. Also wenn der Inhalt der Liste '6 3 1' ist und jemand will wieder ne '3' einfügen, soll ne Mitteilung kommen, das die '3' schon drin ist.

    Entweder ich steh total auf dem Schlauch oder ich blicks einfach ned. Alle meiner Versuche das zu lösen gingen bisher schief.

    Hier der funktionierende Code, ohne dem Abfangen von Doppeleingaben.

    void sortiert_einfuegen(int s_zahl)
    {
       struct element *zeiger, *zeiger1;
    
       /* 1. Element der Liste? */
       if(anfang==NULL)
            einfuegen(s_zahl);
       /*Es ist nicht das 1. Element. Wir suchen so lange, bis das
         gesuchte Element gefunden wird oder wir auf NULL stoßen*/
       else
          {
             zeiger=anfang;
    
             while(zeiger != NULL && (zeiger->zahl >= s_zahl))
             {
                  zeiger=zeiger->next;
             }
    
             /*Falls der Zeiger auf NULL zeigt, können wir unser
               Element hinten anhängen, da unser neues Element das
               "grösste" zu sein scheint */
             if(zeiger==NULL)
                {
                einfuegen(s_zahl);
                }
             /*Ist unser neues Element das kleinste und somit
               kleiner als das 1. Element, so müssen wir es an
               den Anfang hängen */
             else if(zeiger==anfang)
                {
                   anfang=(struct element *)
                                malloc(sizeof(struct element));
                   if(NULL == anfang)
                      {
                         fprintf(stderr, "Kein Speicher\n");
                         return;
                      }
                   anfang->zahl=s_zahl;
                   anfang->next=zeiger;
                }
              /*Die letzte Möglichkeit ist, dass wir das Element
                irgendwo in der Mitte einfügen müssen*/
             else
             {
                   zeiger1=anfang;
                   /*Wir suchen das Element, das vor dem
                     Zeiger zeiger steht*/
                   while(zeiger1->next != zeiger)
                     zeiger1=zeiger1->next;
                   zeiger=(struct element *)
                                 malloc(sizeof(struct element));
                   if(NULL == zeiger)
                      {
                         fprintf(stderr, "Kein Speicher");
                         return;
                      }
                   zeiger->zahl=s_zahl;
                    /*Wir fügen das neue Element ein*/
                   zeiger->next=zeiger1->next;
                   zeiger1->next=zeiger;         
             }//Ende else
          }//Ende else
          ausgabe();
    }
    

    Wär nett, wenn mir jemand helfen könnte.

    Gruß RubDec



  • hi,

    hinweis: mein text ist in den kommentaren, die am zeilenanfang beginnen.

    RubDec schrieb:

    void sortiert_einfuegen(int s_zahl)
    {
       struct element *zeiger, *zeiger1;
    
       /* 1. Element der Liste? */
       if(anfang==NULL)
            einfuegen(s_zahl);
       /*Es ist nicht das 1. Element. Wir suchen so lange, bis das
         gesuchte Element gefunden wird oder wir auf NULL stoßen*/
       else
          {
             zeiger=anfang;
             
    /*
             while(zeiger != NULL && (zeiger->zahl >= s_zahl))
    ersetzen durch
             while(zeiger != NULL && (zeiger->zahl > s_zahl))
    , siehe weiter unten.
    */
             {
                  zeiger=zeiger->next;
             }
    
             /*Falls der Zeiger auf NULL zeigt, können wir unser
               Element hinten anhängen, da unser neues Element das
               "grösste" zu sein scheint */
             if(zeiger==NULL)
                {
                einfuegen(s_zahl);
                }
    
    /* 
    
    was weisst du an dieser stelle? zeiger != NULL, d.h. wir haben einen element
    zeiger, für den gilt: zeiger->zahl < s_zahl. problem: da dass eine einfach
    verkettete liste ist, hast du keine möglichkeit mehr, das element vor zeiger zu 
    prüfen; denn über das springt die while-schleife! du musst also in der 
    while-schleife vorher >= durch > ersetzen; dadurch überspringst du nur die echt 
    größeren elemente. für zeiger gilt dann: zeiger->zahl <= s_zahl. das zu testen ist dann einfach: 
    
    else if (zeiger->zahl == s_zahl) {
       bash_caller_appropriately ();
    }
    
    */
    
             /*Ist unser neues Element das kleinste und somit
               kleiner als das 1. Element, so müssen wir es an
               den Anfang hängen */
             else if(zeiger==anfang)
                {
                   anfang=(struct element *)
                                malloc(sizeof(struct element));
                   if(NULL == anfang)
                      {
                         fprintf(stderr, "Kein Speicher\n");
                         return;
                      }
                   anfang->zahl=s_zahl;
                   anfang->next=zeiger;
                }
    [...]
    

    -- leuchtturm



  • Danke Dir,

    Ich werde deine Vorschlag mal umsetzen....

    😋


Anmelden zum Antworten