verkettete Liste

neuling5

Grünschnabel
brauche Hilfe bei verkettete Liste

Hallo Leute,

wie mein Nick schon sagt bin neuling in diesem Thema.
Ich habe eine Aufgabenstellung bekommen bei der ich aus einer einfach verketteten Liste eine doppelt verkette machen soll.
Als erstes wollte ich in der einfach verketteten Liste nun einen Zeiger einfügen der immer auf das ende der Liste zeigt und über diesen die neuen Werte "inhalt" anfügen.
Doch leider scheitert es schon dabei sehe irgendwie vor lauter Bäume den Wald nicht mehr.

Wer kann mir anhand des Beispiels helfen das ich es endlich richtig verstehe
Mir Brummt schon der Kopf ohne Ende.

Code:
#include "stdafx.h"

using namespace System;

//die Struktur für den verwalteten Heap
ref struct beispiel {
	int inhalt;
	beispiel ^next;
	
};

void einfuegen(int inhaltneu, beispiel ^anfang) {

	beispiel ^zeiger;
	zeiger=anfang;

	while (zeiger->next!=nullptr) {
		zeiger=zeiger->next;
	}
	
	zeiger->next=gcnew beispiel;
	zeiger=zeiger->next;
	zeiger->inhalt=inhaltneu;

}
void ausgabe(beispiel ^anfang) {
	beispiel ^zeiger;
	zeiger=anfang;
	Console::WriteLine("{0}", zeiger->inhalt);

	while (zeiger->next != nullptr) {
			zeiger = zeiger->next;
			Console::WriteLine("{0}", zeiger->inhalt);
	}

}

int main(array<System::String ^> ^args)
{
	
	beispiel ^anfang;
	
	anfang=gcnew beispiel;
	anfang->inhalt=0;
	
	for (int schleife=1;schleife<5;schleife++) {
		einfuegen(schleife, anfang);
		
	}

	
	ausgabe(anfang);

	return 0;
}
 
Zuletzt bearbeitet:
Hmm,

scheinbar kann oder mag mier keiner hier weiter helfen.
Somit verabschiede ich mich und wünsche euch allen hier im Forum noch viel Spaß.
 
Hmm,

scheinbar kann oder mag mier keiner hier weiter helfen.
Somit verabschiede ich mich und wünsche euch allen hier im Forum noch viel Spaß.

naja, so schnell gehts dann auch net immer ;)

hm, was ich bei deinem beispiel nicht verstehe, du hast einen struct für eine einfach verkette liste, und den willst du da dann erweitern

ich würd das ganze so lösen, dast du einen 2ten struct hast, wos 2 zeiger gibt (prev, next) , dann läufst die einfach verkette liste durch, und erzeugst dir nebenbei mit dem werten dieser knoten eine neue doppelt verkette liste (dazu schreibst dir am besten eine methode append(int value, List l) die hinten an die doppelt verkette liste anfügt

danach löscht die 1. liste

mfg
 
Hallo,

erst einmal Danke für die Antwort.

Hmm ich glaube ich habe meine Anfrage etwas falsch formuliert,
das Endziel ist zwar eine doppelt verkettete Liste aber für den Anfang um die Sache etwas besser zu verstehen (hoffe ich) möchte ich die jetzt vorhandene einfache Liste nur etwas "frisieren".
So wie sie im Moment geschrieben ist hangel ich mich ja immer vom Anfang zum Ende durch. Ich möchte jetzt durch das einfügen eines Zeigers auf das Ende erreichen das der "inhalt" über diesen immer gleich an das Ende eigefügt wird.

Hatte es so versucht unter anderem
Code:
#include "stdafx.h"

using namespace System;

//die Struktur für den verwalteten Heap
ref struct beispiel {
	Int32 inhalt;
	beispiel ^next;
	
};

void einfuegen(Int32 inhaltneu, beispiel ^ende) {
	
	
	ende->next=ende;
	ende->next=gcnew beispiel;
	ende=ende->next;
	ende->inhalt=inhaltneu;
	

	
}
void ausgabe(beispiel ^anfang) {
	beispiel ^zeiger;
	zeiger=anfang;
	Console::WriteLine("{0}", zeiger->inhalt);

	while (zeiger->next != nullptr) {
			zeiger = zeiger->next;
			Console::WriteLine("{0}", zeiger->inhalt);
	}

}

int main(array<System::String ^> ^args)
{
	
	
	beispiel ^ende;
	beispiel ^anfang;

	anfang=gcnew beispiel;
	anfang->inhalt=0;
	ende=anfang;

	for (Int32 schleife=1;schleife<5;schleife++) {
		einfuegen(schleife, ende);
		
	}

	
	ausgabe(anfang);

	return 0;
}

aber da kommt nur als Ausgabe
0
4
Also keine Liste mehr :confused:
 
du siehst echt den Baum vor lauter wald nicht mehr ;)

also nun mal zur erklärung warum bei dir nur 0 und 4 in der liste steht (was natürlich noch immer eine liste ist)

du hast zuerst "anfang", "ende" die gleich sind und 0 steht drinen

dann fügst du in einfügen einen neuen knoten an next hinzu, was auch noch stimmt, nur das problem das du jetzt hast, ist das ende in der main anders ist als in der funktion

in einfügen ist ende der knoten mit 1

in der main wo das nächste mal einfügst, ist aber der knoten ende noch immer der 0er... das heißt beim nächsten mal einfügen wird wieder ein neuer knoten an 0-> angefügt, der 1er verschwindet im nirvana, und so gehts weiter

drum bleibt am ende nur knoten 0+4 über, knoten 1+2+3 verschwinden

welche möglichkeiten gibt es, das du das fixt?
1. sehr unschön, du machst in main in der hauptschleife ende = ende->next;
wirklich nicht schön, nicht sinn der sache, das wäre so der quickfix damit du siehst das deine lösung okay ist

2. ändere einfügen auf call-by-reference, somit ende verändert wird, da hier nur ein wert verändert wird, kannst dus ja für c typisch machen wie z.bsp. das du die struktur zurückgibst

C:
beispiel einfuegen(Int32 inhaltneu, beispiel ^ende) {
	...
	return ende;
}

dann musst du ende in deiner main nur mehr immer aktualisieren indem du das z.bsp so aufrufst:

C:
main...() {
	...
	for (Int32 schleife=1;schleife<5;schleife++) {
		ende = einfuegen(schleife, ende);
	}
}

aber das ist um ehrlich zu sein alles schmafu
meiner Meinung nach, verwendet man eine liste definitiv anders

du hast deine liste, gegeben durch den zeiger Liste, das ende einer einfach verketteten liste ist egal, da man mit iterieren dahin kommt, anders natürlich dann bei der doppelt verketteten liste

verwende eine methode hintenEinfügen(Beispiel liste, Integer neuerWert)

beispiel code in etwa:

C:
#include "stdafx.h"

using namespace System;

//die Struktur für den verwalteten Heap
ref struct beispiel {
	Int32 inhalt;
	beispiel ^next;
	
};

void hintenEinfuegen(Int32 inhaltneu, beispiel ^liste) {
       hier musst du zuerst mit einer while schleife den letzten knoten suchen
       an den letzten knoten hängst du dann mit dem bereits bekannten code 
       einen neuen knoten an
}

void ausgabe(beispiel ^liste) {
...
}

int main(array<System::String ^> ^args) {
	beispiel ^liste;

	liste=gcnew beispiel;
	liste->inhalt=0;

	for (Int32 schleife=1;schleife<5;schleife++) {
		hintenEinfuegen(schleife, liste);
	}
	ausgabe(liste);
	return 0;
}

das mit dem anfang und ende merken, und dann darauf achten das ende immer aufs ende zeigt ist net das wahre
und wird auch nicht bei einer doppelt verketteten liste verwendet!

mfg
 
Zuletzt bearbeitet:
Hallo Proko,

erst einmal riesen Dank für deine Hilfe

das mit ende = ende->next; in der Schleife hatte ich auch schon versucht war nur an der falschen Stelle wie ich jetzt gemerkt habe hatte es vor einfuegen(schleife, ende); und nicht dahinter dadurch kam immer ein absturz und ich dachte bin auf dem falschen weg.

deine zweite Lösung sieht natürlich besser aus werde die jetzt mal versuchen
und das mit der doppelten werde ich dann wohl jetzt auch schaffen hoffe ich

DAAANKE
 
Zurück