Zwei einfach verkettete Listen aneinander hängen



  • ich möchte zwei einfach verkettete listen aneinander hängen.

    hierbei sieht meine klasse für listen generell so aus:

    class Liste
    {
    private:
    	int data;
    	Liste *next;
    	Liste *anker = nullptr;
    	Liste *zeiger;
    

    meine Methode so:

    methode(Liste erste, Liste zweite)
    	{
    		Liste komplett;
    
    		komplett.anker->data=erste.anker->data;
    
    		erste.zeiger = erste.anker;
    
    		while (erste.zeiger->next != nullptr)
    		{
    			komplett.zeiger->data = erste.zeiger->data;
    			zeiger = zeiger->next;
    		}
    
    		zweite.zeiger = anker;
    
    		while (zweite.zeiger->next != nullptr)
    		{
    			komplett.zeiger->data = zweite.zeiger->data;
    			zeiger = zeiger->next;
    		}
    
    		erste.zeiger = anker;
    		int a1 = 0;
    		while (erste.zeiger->next != nullptr)
    		{
    			++a1; erste.zeiger = erste.zeiger->next;
    		}}
    

    (nur teil des insgesamten programms)

    ich hatte absolut Keine Ahnung wie ich das anstellen soll und bin jetzt mit so etwas geendet.
    als fehler wird zugriffsfehler angezeigt.
    und ich Weiß das Programm lässt vielen könnenden einen kalten schauer über den rücken laufen... (stehe eben noch am anfang)

    insgesamt antworten bitte möglichst für laien verständlich formulieren.
    vielen dank.



  • Erklär erstmal, warum deine Listeneinträge 3 Pointer brauchen. 😕



  • Das ist auch kein Minimalbeispiel.
    -Was ist 'zeiger' (Zeile 12)?
    -Im while wird erste.zeiger oder erste.zeiger->next nicht geändert => endlos Schleife.
    -Falls der Konstruktor nicht noch was überraschendes macht, ist komplett.anker null und komplett.anker->data = bla nicht so vorteilhaft.



  • drei=zweizuviel schrieb:

    Erklär erstmal, warum deine Listeneinträge 3 Pointer brauchen. 😕

    ich hatte aus aufgaben die ich vor dieser bearbeitet habe, *next und *anker übernommen. und *zeiger habe ich dazu erstellt damit ich irgendwie durch beide listen laufen kann und die komplette liste.
    wenn ich in der Methode nur " erste *ptr = anker " geschrieben habe -dass ich eben einen zeiger auf den anfang der liste habe- wurde mir das als fehler angezeigt , dass ptr nicht definiert sei.
    und ich wollte erstmal ein ungefäheres programm-Konstrukt haben, bevor ich hier meine fragen stelle 😕



  • Jockelx schrieb:

    Das ist auch kein Minimalbeispiel.
    -Was ist 'zeiger' (Zeile 12)?
    -Im while wird erste.zeiger oder erste.zeiger->next nicht geändert => endlos Schleife.
    -Falls der Konstruktor nicht noch was überraschendes macht, ist komplett.anker null und komplett.anker->data = bla nicht so vorteilhaft.

    hatte es jetzt so verändert:

    methode(Liste erste, Liste zweite)
    	{
    		Liste komplett; //Liste, die am ende entstehen soll aus den 2 Listen
    
    		erste.zeiger = erste.anker; //Zeiger d. 1. Liste wird auf deren anfang gesetzt
    		komplett.zeiger = komplett.anker; //Zeiger d. kompletten Liste wird auf deren anfang gesetzt
    
    		while (erste.zeiger->next != nullptr) //bis ende d. 1. liste erreicht ist
    		{
    			komplett.zeiger = erste.zeiger; //werte aus 1. liste in komplette übertragen
    			erste.zeiger = erste.zeiger->next;//zeiger der 1. liste weiterverschieben
    			komplett.zeiger = komplett.zeiger->next; //zeiger der kompletten liste weiterverschieben
    		}
    
    		zweite.zeiger = zweite.anker; //zeiger d. 2. liste auf deren anfang setzen
    
    		while (zweite.zeiger->next != nullptr)//bis ende d. 2. liste erreicht ist
    		{
    			komplett.zeiger = zweite.zeiger; 
    			zweite.zeiger = zweite.zeiger->next;
    			komplett.zeiger = komplett.zeiger->next;
    		}
    		komplett.zeiger->next = nullptr; //next-pointer d. endes d. kompletten liste soll den nullpointer besitzen
    }
    

    ich hoffe ist nun ersichtlicher was ich mir so überlegt habe.

    meine Überlegungen waren, dass ja der anker der neuen kompletten liste mit dem anker der ersten listen übereinstimmt, bzw. mit dem wert.
    darum wollte ich versuchen die erste liste und (den anfang) der neuen liste zu durchlaufen und deren werte iwie gleich zu setzen.
    und dann halt weiter mit der zweiten liste machen.

    ich weiß es ist alles was unübersichtlich 😕 nur echt garkeine Ahnung



  • Dangling schrieb:

    drei=zweizuviel schrieb:

    Erklär erstmal, warum deine Listeneinträge 3 Pointer brauchen. 😕

    ich*zeiger habe ich dazu erstellt damit ich irgendwie durch beide listen laufen kann und die komplette liste.
    wenn ich in der Methode nur " erste *ptr = anker " geschrieben habe -dass ich eben einen zeiger auf den anfang der liste habe- wurde mir das als fehler angezeigt , dass ptr nicht definiert sei.

    zeiger* hat aber doch trotzdem in der Klasse nix verloren.

    Liste* zeiger = erste.anker; // zeiger zeigt auf Listenbeginn
    

    Danach wird es mir zu chaotisch. Du solltest dir erstmal überlegen, ob du die Parameter-Listen wirklich ändern willst.
    Falls dir das egal ist, reicht komplett.zeiger = erste.zeiger; letztes Element->next = zweite.zeiger; alle anker ab da neu setzen.



  • Jockelx schrieb:

    Danach wird es mir zu chaotisch. Du solltest dir erstmal überlegen, ob du die Parameter-Listen wirklich ändern willst.
    Falls dir das egal ist, reicht komplett.zeiger = erste.zeiger; letztes Element->next = zweite.zeiger; alle anker ab da neu setzen.

    habe es was auskommentiert, hoffe es ist nun klarer.

    inwieweit werden die listen verändert? ist anscheinend unbewusst passiert.

    wenn ich das Programm nun ausführe wird in der kompletten liste nur die erste liste übernommen und nicht die zweite drangehängt 😕

    vllt einen anderen Lösungsvorschlag/-Ansatz zur lösung des Problems des aneinanderhängen von 2 listen?



  • Hallo ich wollte nochmal darum bitten dass mir jemand dabei hilft zwei einfachverkettete listen aneinander zu hängen!

    mein code sieht nun so aus:

    {
    	zusammenfuegen(Liste erste, Liste zweite)
    {	Liste *ptr1 = anker; //ptr1 = Zeiger auf neuer Liste
    		Liste *ptr2 = erste.anker; //ptr2 = Zeiger auf den beiden zusammenzufügenden Listen
    		                           //-> soll zunächst auf den Anfang der ersten Liste gesetzt werden
    
    		Liste *neuer_eintrag = new Liste; //es soll Speicherplatz für die neue Einträge in die komplette Liste reserviert werden
    		neuer_eintrag->data = ptr2->data; //der Wert des neuen Eintrags entspricht dem Wert des Elements auf dass der Pointer ptr2 zeigt
    		neuer_eintrag->next = 0; //der next-Pointer d. neuen Eintrags ist immer der nullptr
    
    		while (ptr2->next != nullptr)   //bis das Ende der ersten Liste erreicht ist
    		{
    
    		if (anker == nullptr) //die komplette Liste ist noch leer
    		{
    			anker = neuer_eintrag; //der erste neue Eintrag ist der Anker der Liste
    		}
    		else
    		{
    			neuer_eintrag = new Liste; //neuen Speicherplatz reservieren
    			ptr1->next = neuer_eintrag; //der neue eintrag soll an den eintrag auf den der pointer derweil zeigt drangehängt werden
    			ptr1 = ptr1->next; //der Zeiger auf die komplette Liste soll weiterverschoben werden
    		}
    
    		ptr2 = ptr2->next; //der Zeiger auf die erste Liste soll weiterverschoben werden
    
    		};
    
    		ptr1 = neuer_eintrag; //der letzte eintrag der ersten Liste (da, er aus der while-schleifen-bedingung rausfällt) 
    		                      //soll auch eintrag der kompletten liste werden
    
    		ptr2 = zweite.anker; //der zeiger ptr2 soll nun auf den anfang der zweiten Liste gesetzt werden
    
    		while (ptr2->next != nullptr) //bis das ende der zweiten liste erreicht wird
    		{
    			neuer_eintrag = new Liste; //reservierung von neuem speicherplatz
    
    			ptr1->next = neuer_eintrag; 
    			ptr1 = ptr1->next;
    
    			ptr2 = ptr2->next;
    
    		};
    
    		ptr1 = neuer_eintrag;}
    

    wenn ich die Listen:
    7-5-8
    und 4-17-12
    habe kommt bloß raus: 7-0-0-0

    hat jemand einen vorschlag wie ich das verbinden richtig anstellen könnte?
    bzw wenn der ansatz okay ist, wodrin der fehler liegt?
    danke



  • Wozu gibt es mehrere new, wenn du doch Listen aneinanderhängen willst?
    Globale Variablen wie anker werden spätestens jetzt zu einem Problem.
    Warum sind die Funktionsparameter Kopien?
    Es ist immer noch chaotisch.



  • Wenn man zwei Liste aneinanderhaengt, so gibt es am Ende keine neue Liste. Man aendert nur die erste Liste so, das an deren Ende die zweite Liste haengt. An der zweiten Liste kann man gar nicht erkennen, das die erste Liste noch dran haengt. Das ist ein Grundsatz der einfach verketteten Liste.


Log in to reply