2 Rückgabewerten in Struktur bei einer doppeltverketten Liste

Hi an Alle,

ich komme einfach nicht weiter und benötige Unterstützung.

Ich habe eine einfache funktionsfähige verkette Liste geschrieben. Nun soll ich sie in eine doppelverkette Liste erweitern inkl. 2 zusätzliche Funktionen einbauen.

1. Funktion: alle eingegebene Einträge rückwärst ausgeben lassen.
2. Funktion: die eingegeben Namen sollen sortiert von A-Z ausgegeben werden.

1 Problem: bei der Funktion "knoten *add_adress", versuche ich die ganze Zeit "return anfang und return ende" zurückzugeben, damit die Einträge vorwärts und rückwärst ausgegeben werden können, habe eine Referenzierung angewendet, ohne erfolg.

2 Problem: Ich weiß nicht wie die "sortiert" Funktion aufgebaut werden soll, ich habe das bubblesort-prinzip im Sinn aber kann das nicht systaxmäßig umsetzen.

Danke für eure Ideen!

------ Teilweise vom Quellcode ----------

#include <iostream>
#include <string>
using namespace std;

struct knoten{
    string name, adresse, telefon;
    knoten *next;
    knoten *last;
};

knoten *anfang = NULL;
knoten *ende = NULL;

knoten *add_adress(string name_1, string adresse_1, string telefon_1);
knoten *delete_adress(string name_2);
knoten *print_telefon(string name_3);
knoten *rueckgabe(knoten *x);

void sort_name(knoten *e);
void print_adresses_forward(const knoten *n);
void print_adresses_backward(const knoten *m);

int main(){

    knoten *node;
    string name_n, adresse_n, telefon_n;
    int wahl;

    do{
        cout <<"\n---------------------------------\n";
        cout <<"|           Wahlmenue           |\n";
        cout <<"---------------------------------\n";
        cout <<"1. neuer Eintrag                |\n";
        cout <<"2. Adresse anzeigen (forward)   |\n";
        cout <<"3. Adresse anzeigen (backward)  |\n";
        cout <<"4. Namen sortieren              |\n";
        cout <<"5. Telefon anzeigen             |\n";
        cout <<"6. Eintrag loeschen             |\n";
        cout <<"7. Beenden                      |\n";
        cout <<"---------------------------------\n";
        cout <<"geben Sie eine Zahl zwischen 1-7 ein: ";
        cin >> wahl;

        switch (wahl){
            case 1:
                    cin.ignore();       
                    cout <<"\nName eingeben: ";
                    getline(cin,name_n);

                    cout <<"\nAdresse eingeben: ";
                    getline(cin,adresse_n);

                    cout <<"\nTelefon eingeben: ";
                    getline(cin,telefon_n);

                    node = add_adress(name_n, adresse_n, telefon_n);
                    break;

            case 2:
                    print_adresses_forward(node);
                    break;

            case 3:
                    print_adresses_backward(node);
                    break;

            case 4:

                    sort_name(node);
                    break;

            case 5:
                    cin.ignore();
                    cout <<"\nfuer Telefonanzeige, bitte einen Name eingeben: ";
                    getline(cin,name_n);
                                                    ;
                    node = print_telefon(name_n);
                    break;
            case 6:
                    cin.ignore();
                    cout <<"\nzum Loeschen bitte einen Name eingeben: ";
                    getline(cin,name_n);

                    node = delete_adress(name_n);
                    break;
            case 7:
                    break;
            default:
                    cout << "\nFalsche Eingabe, bitte nochmal eingeben!\n";
        }

    }while(wahl != 7);

    return 0;
}

knoten *add_adress(string name_1, string adresse_1, string telefon_1){

    if(anfang == NULL){

        knoten *start_node = new knoten;
        start_node->name = name_1;
        start_node->adresse = adresse_1;
        start_node->telefon = telefon_1;
        start_node->next = NULL;
        start_node->last = NULL;
        anfang = start_node;
        return anfang;

    }else{

        knoten *start_node = anfang;
        knoten *next_node;
        knoten *verweis = new knoten;

        while(start_node->next != NULL){

            start_node = start_node->next;
        }

        next_node = new knoten;
        next_node->name = name_1;
        next_node->adresse = adresse_1;
        next_node->telefon = telefon_1;
        next_node->next = NULL;
        next_node->last = NULL;
        ende = next_node;
        start_node->next = next_node;

        verweis = rueckgabe(next_node);
        return ende;
    }

}

knoten *rueckgabe (knoten *x){

    anfang = x;
    return anfang;
}

void print_adresses_forward(const knoten *n){

    if(anfang == NULL){

        cout <<"\nListe leer!\n";

    }else{

        cout <<"\n---------------------------------------------------------------------------\n";
        cout <<"|                                 Liste                                   |";
        cout <<"\n---------------------------------------------------------------------------\n";
        cout <<"1. Name: "<< n->name <<"    Adresse: "<< n->adresse << "    Telefon: "<< n->telefon;
        cout <<"\n---------------------------------------------------------------------------\n";

        for(int a = 2; n->next != NULL; a++){

            n = n->next;

            cout << a <<". Name: "<< n->name <<"    Adresse: "<< n->adresse << "    Telefon: "<< n->telefon;
            cout <<"\n---------------------------------------------------------------------------\n";
        }
    }
}

void print_adresses_backward(const knoten *m){

}

knoten *delete_adress(string name_2){

    if(anfang == NULL){

        cout <<"\nListe leer!\n";

    }else if(anfang->name == name_2){

        knoten *d = anfang;
        anfang = anfang->next;
        cout <<"\nder Name "<<'"'<< d->name <<'"'<<" wird geloescht!\n"; //debug
        delete d;
        cout <<"\nEintrag geloescht!\n";
                                        // debug: cout<<"\nAnfangsknoten wurde geloescht\n";

    }else{

        knoten *t = anfang;

        while(t->next != NULL && t->next->name != name_2){

            t = t->next;

        }if(t->next == NULL){

            cout << "\nder Name ist nicht in der Liste enthalten!\n";

        }else{

            knoten *g = t->next;
            /*t->next = t->next->next;*/
            knoten *h = g->next;
            t->next = h;
            cout <<"\nder Name "<<'"'<< g->name <<'"'<<" wird geloescht!\n"; //debug
            delete g;
            cout <<"\nEintrag geloescht!\n";
                                        // debug: cout<<"\nnaechste Knoten wurde geloescht\n";
        }

    }

    return anfang;
}

knoten *print_telefon(string name_3){

    if(anfang == NULL){

        cout <<"\nListe leer!\n";

    }else if(anfang->name == name_3){

        knoten *zeigen = anfang;
        anfang = anfang->next;
        cout <<"\nTelefonnummer mit dem Name "<<'"'<< zeigen->name <<'"'<< " ist: " <<zeigen->telefon<<'\n';

    }
    else{

        knoten *e = anfang;

        while( e->next != NULL && e->next->name != name_3){

            e = e->next;

        }if(e->next ==NULL){

            cout << "\nist nicht in der Liste enthalten!\n";

        }else{

            knoten *zeigen_1 = e->next;
            e->next = e->next->next;
            cout << "\nTelefonnummer mit dem Name "<<'"'<< zeigen_1->name <<'"'<< " ist: "<< zeigen_1->telefon<<'\n';
        }

    }
    return anfang;

}
[code="cpp"][code="cpp"]

TNA

selina schrieb:

1 Problem: bei der Funktion "knoten *add_adress", versuche ich die ganze Zeit "return anfang und return ende" zurückzugeben, damit die Einträge vorwärts und rückwärst ausgegeben werden können, habe eine Referenzierung angewendet, ohne erfolg.

Ich verstehe nicht, was du da machen möchtest bzw was das Problem ist. Du hast doch den Anfang der Liste und das Ende der Liste als globale Zeiger. Daher weist du immer, wo der Anfang und wo das ende ist und kannst von dort die Liste vorwärts oder rückwärts auszugeben.

So ganz verstehe ich nicht, was du möchtest mit "return anfang und return ende" aber bei return kann nur ein Wert stehen. (Das kann aber auch eine struct sein)

GLobale Variablen sind Müll. Packe deine Zeiger anfang und ende in eine struct.
Du kannst dafür auch knoten nehmen next = anfang, last¹ = ende (die nicht genutzten Einträge machen nichts)

Zu add_adress: wenn anfang == NULL ist, sollte auch ende == NULL sein.
Bzw. wenn du den ersten Knoten einbindest, zeigen anfang und ende auf diesen einen Knoten.

Zum sortieren brauchst du eine Funktion, die zwei Knoten vertauscht.
Du kannst den Inhalt vertauschen oder die Zeiger verbiegen.

¹eigentlich heißt der Eintrag prev

mit "return anfang" und "return ende", meinte ich, dass ich in der "add_adress" Funktion nur anfang oder ende (ein von Beiden) zurückgeben kann. Wenn ich bei if{ return anfang; } else{ return anfang; }zurückgebe, kann ich alle Einträge vortwärt ausgeben lassen. Um alle Einträge rückwärts ausgeben, brauche ich auch die Rückgabewerte für "knoten *ende", deshalb versuche ich eine Referenz zu erstellen, damit ich den Wert für "ende" auch zurückgeben kann.

Ihr dürft gern mein Quellcode verändern und verbessern. Mit Quellcode als Beispiel, kann ich mir besser vorstellen.

Ob die Liste vorwärts oder rückwärts ausgegeben wird, hängt nicht vom Startknoten ab, sondern welchen Zweig du verfolgst (next oder last).

Bei void print_adresses_forward ist auch die Abbruchbedingung in der for-Schleife falsch. So bekommst du nie das letzte Element.

for(int a = 2; n != NULL; a++, n->next){

          Ausgabe
        }

ich habe endlose schleife rausbekommen mit

for(int a = 2; n != NULL; a++, n->next){

            cout << a <<". Name: "<< n->name <<"    Adresse: "<< n->adresse << "    Telefon: "<< n->telefon;
            cout <<"\n---------------------------------------------------------------------------\n";
        }

ACnut

bissl offtopic aber du könntest statt bei jeder funktion manuel bindestriche auszugeben einfach manipulatoren benutzen (musst iomanip in deinem projekt inkludieren)

selina schrieb:

ich habe endlose schleife rausbekommen mit

Klar

for(int a = 2; n != NULL; a++, n = n->next){