3. Einsendungen CPBS05F-XX01-N01

Einsendungen CPBS05F-XX01-N01


  • @DRM Hast du bemerkt dass die Frage "Du brauchst Hilfe?" von @SeppJ auch gleichzeitig ein Link ist? Und falls ja: hast du auch draufgeklickt und den Beitrag gelesen?

    0
    D
     1 Antwort
  • D

    @SeppJ

    ich bin ganz Anfänger und habe 2 Einsendungen und ich verstehe die aufgaben nicht richtig und weiß nicht was ich ändern muss... ich bitte um Hilfe 🙂
    CPBS05F-XX01-N01

    Ändern Sie die einfach verkettete Liste aus dem Studienheft so, dass das Ende der Liste nicht bei jedem Anhängen neu ermittelt werden muss, sondern in einem eigenen Zeiger gespeichert wird.
    Dieser Zeiger für das Listenende soll dann beim Anhängen neuer Elemente benutzt werden.
    Zwei kleine Hilfestellungen zur Lösung:
    •Sie müssen dafür sorgen, dass das Listenende nach jedem Anhängen ermittelt wird und auch an die Funktion main() zurückgeliefert wird. Dazu müssen Sie die Funktion zum Anhängen entsprechend verändern.
    •Als Argument beim Anhängen übergeben Sie dann nicht mehr den Listenanfang, sondern das Listenende.

    2.Erweitern Sie die einfach verkettete Liste aus dem Studienheft so, dass sie zu einer doppelt verketteten Liste wird. Ergänzen Sie das Programm außerdem um eine Funktion, die die Liste rückwärts – also vom letzten Element beginnend bis zum Anfang – ausgibt.

    Auch zu dieser Aufgabe zwei Hilfestellungen:
    •Sie benötigen einen neuen Zeiger in der Struktur, der die Adresse des Vorgängerelements aufnehmen kann.
    •Die wichtigste Änderung müssen Sie beim Anhängen des neuen Elements vornehmen. Hier müssen Sie die Adresse des Vorgängerelements in Sicherheit bringen, bevor Sie den Hilfszeiger auf das neue Element verschieben. Dazu können Sie zum Beispiel einen Ausdruck wie hilfszeiger->next->last benutzen. Mit diesem Ausdruck greifen Sie auf einen Zeiger last in dem Element zu, das über hilfszeiger->next angesprochen wird.

    /* ##################################
    Einfach verkettete Liste
    ###################################*/

    #include <iostream>

    using namespace std;

    //die Struktur für die Listenelemente
    struct listenelement
    {
    string daten;
    listenelement* next;
    };
    //eine Funktion zum Anhängen von Elementen an die Liste
    void anhaengen(string datenneu, listenelement* listenanfang)
    {
    //ein lokaler Hilfszeiger, um in der Liste wandern zu
    //können
    listenelement* hilfszeiger;

    //den Hilfszeiger an den Anfang der Liste setzen
    hilfszeiger = listenanfang;

    //durch die Liste gehen, bis das letzte Element erreicht ist
    while(hilfszeiger->next != nullptr)
    hilfszeiger = hilfszeiger->next;

    //ein neues Element an das Ende der Liste anhängen
    hilfszeiger->next = new(listenelement);

    //den Hilfszeiger auf das neue Element setzen
    hilfszeiger = hilfszeiger->next;

    //die Daten in das neue Element eintragen
    hilfszeiger = hilfszeiger->next;

    //ein neues Element an das Ende der Liste anhängen
    hilfszeiger->next = new(listenelement);

    //den Hilfszeiger auf das neue Element setzen
    hilfszeiger = hilfszeiger->next;

    //die Daten in das neue Element eintragen
    hilfszeiger->daten = datenneu;

    //es gibt keinen Nachfolger, daher wird next auf nullptr
    //gesetzt
    hilfszeiger->next = nullptr;
    }
    //Eine Funktion zum Ausgeben aller Elemente
    void ausgeben(listenelement *listenanfang)
    {

    //ein lokaler Hilfszeiger, um in der Liste wandern zu können
    listenelement* hilfszeiger;

    //den Hilfszeiger auf den Anfang der Liste setzen
    hilfszeiger = listenanfang;

    //das erste Element ausgeben
    cout << hilfszeiger->daten << '\n';

    //solange das Ende der Liste noch nicht erreicht ist:
    while (hilfszeiger->next != nullptr)
    {

    //den Hilfszeiger hilfszeiger auf das nächste Element
    //setzen
    hilfszeiger = hilfszeiger->next;

    //Daten ausgeben
    cout << hilfszeiger->daten << '\n';
    }
    }

    //die Liste leeren und Speicher freigeben
    void ende(listenelement* listenanfang)
    {

    //ein lokaler Hilfszeiger, um in der Liste wandern zu
    //können
    listenelement* hilfszeiger;

    //solange noch Elemente in der Liste sind
    while (listenanfang != nullptr)
    {
    //den Hilfszeiger auf das erste Element der Liste
    hilfszeiger = listenanfang;

    //den Zeiger für den Listenanfang auf das nächste
    //Element setzen
    listenanfang = listenanfang->next;

    //den Speicher für das herausgenommene Element
    //freigeben
    delete(hilfszeiger);
    }
    }

    int main ()
    {

    //ein Zeiger auf den Anfang der Liste
    listenelement* listenanfang;

    //das erste Element erzeugen
    listenanfang = new(listenelement);

    //Daten in das erste Element schreiben
    listenanfang->next = nullptr;

    listenanfang->daten = "Element 1";

    //und jetzt weitere Elemente erzeugen
    anhaengen("Element 2", listenanfang);
    anhaengen("Element 3", listenanfang);
    anhaengen("Element 4", listenanfang);

    //die Liste ausgeben

    ausgeben(listenanfang);

    //die Liste wieder abbauen ende(listenanfang);

    return 0;
    }

    Antworten Zitieren 0

    0
  • ?

    Ich glaube lesen wird heutzutage nicht mehr unterrichtet.

    0
  • J

    Mmh, ich bin mir noch nicht sicher. Kannst du vorsichtshalber vielleicht nochmal die Aufgabenstellung senden?

    0
    T
     1 Antwort
  • T

    @Jockelx sagte in Einsendungen CPBS05F-XX01-N01:

    Mmh, ich bin mir noch nicht sicher. Kannst du vorsichtshalber vielleicht nochmal die Aufgabenstellung senden?

    Aber bitte den Code nicht als Code formatieren!

    0
  • W

    Ich vermute ja, dass es sich um eine Aufgabe aus dem Fach "Gesellschaftskunde der Informatik" handelt und eigentlich nur die Reaktion hier im Forum getestet werden soll - und dass die Aufgabe zur verketteten Liste völlig irrelevant ist (ein Thema, das schon x-Mal durchgekaut wurde und nur sehr selten Anwendung findet, da man in der Regel ein Array/vector vorzieht).

    0
  • D

    @hustbaer

    ich bin ganz Anfänger und habe 2 Einsendungen und ich verstehe die aufgaben nicht richtig und weiß nicht was ich ändern muss... ich bitte um Hilfe 🙂
    CPBS05F-XX01-N01

    Ändern Sie die einfach verkettete Liste aus dem Studienheft so, dass das Ende der Liste nicht bei jedem Anhängen neu ermittelt werden muss, sondern in einem eigenen Zeiger gespeichert wird.
    Dieser Zeiger für das Listenende soll dann beim Anhängen neuer Elemente benutzt werden.
    Zwei kleine Hilfestellungen zur Lösung:
    •Sie müssen dafür sorgen, dass das Listenende nach jedem Anhängen ermittelt wird und auch an die Funktion main() zurückgeliefert wird. Dazu müssen Sie die Funktion zum Anhängen entsprechend verändern.
    •Als Argument beim Anhängen übergeben Sie dann nicht mehr den Listenanfang, sondern das Listenende.

    2.Erweitern Sie die einfach verkettete Liste aus dem Studienheft so, dass sie zu einer doppelt verketteten Liste wird. Ergänzen Sie das Programm außerdem um eine Funktion, die die Liste rückwärts – also vom letzten Element beginnend bis zum Anfang – ausgibt.

    Auch zu dieser Aufgabe zwei Hilfestellungen:
    •Sie benötigen einen neuen Zeiger in der Struktur, der die Adresse des Vorgängerelements aufnehmen kann.
    •Die wichtigste Änderung müssen Sie beim Anhängen des neuen Elements vornehmen. Hier müssen Sie die Adresse des Vorgängerelements in Sicherheit bringen, bevor Sie den Hilfszeiger auf das neue Element verschieben. Dazu können Sie zum Beispiel einen Ausdruck wie hilfszeiger->next->last benutzen. Mit diesem Ausdruck greifen Sie auf einen Zeiger last in dem Element zu, das über hilfszeiger->next angesprochen wird.

    /* ##################################
    Einfach verkettete Liste
    ###################################*/

    #include <iostream>

    using namespace std;

    //die Struktur für die Listenelemente
    struct listenelement
    {
    string daten;
    listenelement* next;
    };
    //eine Funktion zum Anhängen von Elementen an die Liste
    void anhaengen(string datenneu, listenelement* listenanfang)
    {
    //ein lokaler Hilfszeiger, um in der Liste wandern zu
    //können
    listenelement* hilfszeiger;

    //den Hilfszeiger an den Anfang der Liste setzen
    hilfszeiger = listenanfang;

    //durch die Liste gehen, bis das letzte Element erreicht ist
    while(hilfszeiger->next != nullptr)
    hilfszeiger = hilfszeiger->next;

    //ein neues Element an das Ende der Liste anhängen
    hilfszeiger->next = new(listenelement);

    //den Hilfszeiger auf das neue Element setzen
    hilfszeiger = hilfszeiger->next;

    //die Daten in das neue Element eintragen
    hilfszeiger = hilfszeiger->next;

    //ein neues Element an das Ende der Liste anhängen
    hilfszeiger->next = new(listenelement);

    //den Hilfszeiger auf das neue Element setzen
    hilfszeiger = hilfszeiger->next;

    //die Daten in das neue Element eintragen
    hilfszeiger->daten = datenneu;

    //es gibt keinen Nachfolger, daher wird next auf nullptr
    //gesetzt
    hilfszeiger->next = nullptr;
    }
    //Eine Funktion zum Ausgeben aller Elemente
    void ausgeben(listenelement *listenanfang)
    {

    //ein lokaler Hilfszeiger, um in der Liste wandern zu können
    listenelement* hilfszeiger;

    //den Hilfszeiger auf den Anfang der Liste setzen
    hilfszeiger = listenanfang;

    //das erste Element ausgeben
    cout << hilfszeiger->daten << '\n';

    //solange das Ende der Liste noch nicht erreicht ist:
    while (hilfszeiger->next != nullptr)
    {

    //den Hilfszeiger hilfszeiger auf das nächste Element
    //setzen
    hilfszeiger = hilfszeiger->next;

    //Daten ausgeben
    cout << hilfszeiger->daten << '\n';
    }
    }

    //die Liste leeren und Speicher freigeben
    void ende(listenelement* listenanfang)
    {

    //ein lokaler Hilfszeiger, um in der Liste wandern zu
    //können
    listenelement* hilfszeiger;

    //solange noch Elemente in der Liste sind
    while (listenanfang != nullptr)
    {
    //den Hilfszeiger auf das erste Element der Liste
    hilfszeiger = listenanfang;

    //den Zeiger für den Listenanfang auf das nächste
    //Element setzen
    listenanfang = listenanfang->next;

    //den Speicher für das herausgenommene Element
    //freigeben
    delete(hilfszeiger);
    }
    }

    int main ()
    {

    //ein Zeiger auf den Anfang der Liste
    listenelement* listenanfang;

    //das erste Element erzeugen
    listenanfang = new(listenelement);

    //Daten in das erste Element schreiben
    listenanfang->next = nullptr;

    listenanfang->daten = "Element 1";

    //und jetzt weitere Elemente erzeugen
    anhaengen("Element 2", listenanfang);
    anhaengen("Element 3", listenanfang);
    anhaengen("Element 4", listenanfang);

    //die Liste ausgeben

    ausgeben(listenanfang);

    //die Liste wieder abbauen ende(listenanfang);

    return 0;
    }

    Antworten Zitieren 0

    0
    F
     1 Antwort
  • Mod

    Schon besser, aber so ganz sicher bin ich mir noch nicht. Kannst du es noch einmal posten, so dass ich es noch einmal lesen kann?

    1
    D
     1 Antwort
  • F

    @DRM sagte in Einsendungen CPBS05F-XX01-N01:

    Antworten Zitieren 0

    Ich finde man kann sich wenigstens beim Copy+Paste schon ein bisschen mehr Mühe geben. Die Foren-UI-Elemente sind echt noch das Sahnehäubchen 😉

    0
  • D

    @SeppJ
    ja klar 🙂

    #include <iostream>
    using namespace std;
    struct listenelement
    {
    string daten;
    listenelement* next;
    listenelement* end;
    };
    void anhaengen(string datenneu, listenelement* listenanfang)
    {
    listenelement* hilfszeiger = listenanfang;
    listenelement * listenend = nullptr;

    while(hilfszeiger->next != nullptr)
{
    hilfszeiger->daten = datenneu;
    hilfszeiger->next = new(listenelement);
    hilfszeiger = hilfszeiger->next;
    hilfszeiger->next = hilfszeiger->next->next;
    hilfszeiger->next = listenend->end;
}

    }

    void ausgeben(listenelement listenanfang)
    {
    listenelement     hilfszeiger;
    hilfszeiger = listenanfang;
    cout << hilfszeiger->daten << '\n';
    while (hilfszeiger->next != nullptr)
    {
    hilfszeiger = hilfszeiger->next;
    cout << hilfszeiger->daten << '\n';
    }
    }

    void ende(listenelement* listenanfang)
    {
    listenelement* hilfszeiger = nullptr;
    while (listenanfang != nullptr)
    {
    hilfszeiger = listenanfang;
    listenanfang = listenanfang->next;
    delete(hilfszeiger);
    }
    }
    int main ()
    {
    listenelement* listenanfang;
    auto listenend = nullptr;
    for(int i= 0; i< 5 ; i++)
    {
    listenanfang->daten = "element"[i];
    listenanfang = new(listenelement);
    listenanfang = listenanfang->next;
    listenanfang->next = listenanfang->next->next;
    listenanfang->next = listenend;
    cout << " die adresse des anfangs des elements " << i << " ist: " << listenanfang << " die adresse der ende der liste ist: " << listenend << '\n' ;
    }
    anhaengen(listenanfang->daten, listenanfang);
    ausgeben(listenanfang);
    return 0;

    }

    -1
  • Mod

    Danke! 👍

    0
  • ?

    So geht das aber nicht, jetzt fehlt ja die aufgabe und die kommentare...wie soll man denn da helfen?

    0
    D
     1 Antwort

  • Ich befürchte, wenn das nicht ein albernes Spiel ist, dass es eine ernste Sache ist.
    Beides in der jetzigen Form fortzuführen, halte ich für nicht sinnvoll.
    Nur so ein Gedanke, weil ich mir schwerlich einen Reim daraus machen kann.

    0
  • D

    @Cardiac
    hey sorry
    bin neu hier und habe gedacht dass ich schon die aufgäbe mitgeteilt habe 🙂

    Ändern Sie die einfach verkettete Liste aus dem Studienheft so, dass das Ende der Liste nicht bei jedem Anhängen neu ermittelt werden muss, sondern in einem eigenen Zeiger gespeichert wird.
    Dieser Zeiger für das Listenende soll dann beim Anhängen neuer Elemente benutzt werden.
    Zwei kleine Hilfestellungen zur Lösung:
    •Sie müssen dafür sorgen, dass das Listenende nach jedem Anhängen ermittelt wird und auch an die Funktion main() zurückgeliefert wird. Dazu müssen Sie die Funktion zum Anhängen entsprechend verändern.
    •Als Argument beim Anhängen übergeben Sie dann nicht mehr den Listenanfang, sondern das Listenende.

    2.Erweitern Sie die einfach verkettete Liste aus dem Studienheft so, dass sie zu einer doppelt verketteten Liste wird. Ergänzen Sie das Programm außerdem um eine Funktion, die die Liste rückwärts – also vom letzten Element beginnend bis zum Anfang – ausgibt.

    Auch zu dieser Aufgabe zwei Hilfestellungen:
    •Sie benötigen einen neuen Zeiger in der Struktur, der die Adresse des Vorgängerelements aufnehmen kann.
    •Die wichtigste Änderung müssen Sie beim Anhängen des neuen Elements vornehmen. Hier müssen Sie die Adresse des Vorgängerelements in Sicherheit bringen, bevor Sie den Hilfszeiger auf das neue Element verschieben. Dazu können Sie zum Beispiel einen Ausdruck wie hilfszeiger->next->last benutzen. Mit diesem Ausdruck greifen Sie auf einen Zeiger last in dem Element zu, das über hilfszeiger->next angesprochen wird.

    #include <iostream>
    using namespace std;
    struct listenelement
    {
    string daten;
    listenelement* next;
    listenelement* end;
    };
    void anhaengen(string datenneu, listenelement* listenanfang)
    {
    listenelement* hilfszeiger = listenanfang;
    listenelement * listenend = nullptr;

    while(hilfszeiger->next != nullptr)
    {
    hilfszeiger->daten = datenneu;
    hilfszeiger->next = new(listenelement);
    hilfszeiger = hilfszeiger->next;
    hilfszeiger->next = hilfszeiger->next->next;
    hilfszeiger->next = listenend->end;
    }
    }

    void ausgeben(listenelement listenanfang)
    {
    listenelement hilfszeiger;
    hilfszeiger = listenanfang;
    cout << hilfszeiger->daten << '\n';
    while (hilfszeiger->next != nullptr)
    {
    hilfszeiger = hilfszeiger->next;
    cout << hilfszeiger->daten << '\n';
    }
    }

    void ende(listenelement* listenanfang)
    {
    listenelement* hilfszeiger = nullptr;
    while (listenanfang != nullptr)
    {
    hilfszeiger = listenanfang;
    listenanfang = listenanfang->next;
    delete(hilfszeiger);
    }
    }
    int main ()
    {
    listenelement* listenanfang;
    auto listenend = nullptr;
    for(int i= 0; i< 5 ; i++)
    {
    listenanfang->daten = "element"[i];
    listenanfang = new(listenelement);
    listenanfang = listenanfang->next;
    listenanfang->next = listenanfang->next->next;
    listenanfang->next = listenend;
    cout << " die adresse des anfangs des elements " << i << " ist: " << listenanfang << " die adresse der ende der liste ist: " << listenend << '\n' ;
    }
    anhaengen(listenanfang->daten, listenanfang);
    ausgeben(listenanfang);
    return 0;

    }

    0

  • Welcher Troll gibt zuerst auf?

    0

  • Ich hoffe CPBS05F-XX01-N01 ist nicht der Name von Seminargruppe und Aufgabenserie. Falls dem doch so ist, kann jetzt dein Professor genau rausfinden, wer deine Hausaufgaben erledigt hat und das Testat dann einfach hier im Forum uploaden.

    0
Anmelden zum Antworten