verkettete Liste

was ist der unterschied zwischen diesen beiden codes:

help->next=head

bzw.

head = head->next

Wer kann mir diese beiden Codes erklären? Was macht der eine und was der andere Ausdruck?

lg

elise

moju schrieb:

was ist der unterschied zwischen diesen beiden codes:
help->next=head
bzw.
head = head->next
Wer kann mir diese beiden Codes erklären? Was macht der eine und was der andere Ausdruck?

lg

1. help ist ein zeiger und zeigt auf ein objekt, -> ist ein operator: dereferenziere und wähle aus, next ist ein member von dem objekt, worauf help zeigt. anders geschrieben:

(*help).next = head;

du setzt also den zeiger des objektes, auf den help zeigt, mit namen next auf den kopf, head. (sieht nach ringschluss aus)

2. du kopierst in den zeiger kopf (head) die adresse, die in next, ein member des objektes, auf das der kopf zeigt, steht

puh, etwas umständlich erklärt..

Chew-Z

Ohne das mit den Zeigern zu berücksichtigen:

a = 2
b = 3

a = b (a und b haben anschliessend den Wert von b = 3)
b = a (a und b haben anschliessend den Wert von a = 2)

wo ist das Problem

hi elise,
du hast zwei Variablen die sich, ohne Compiler-Fehler(Warnung) gegenseitig
zuweisen lassen (hoffentlich). Wer sagt dir das es sich um Zeiger handelt. :p (Klugscheiss)

lookias

in der listenklasse steht ein pointer auf die klasse selbst damit aber beim ausfuehren des progs nicht unendlich viele solche zeiger erzeugt werden was der fall waere weil in next ja wieder ein next steht

hat der next zeiger keine addresse

diese musst du dann erst erzeugen wenn du sie brauchst

also mit blah->next = new blah; das geschieht auf dem heap

vorher kannst du nicht blah=blah->next ausfuehren weil der zeiger keinen speicher zugeordnet hat wuerde dann also nen fehler erzeugen

(das wurde extra so eingebaut hab ich mal gelesen aber mag auch nicht stimmen)

Hi...
Ich habe mal versucht eine einfach verkette Liste zu erstellen, bei der man ein paar zahlen eingeben kann...

class element {

public:
	int zahl;
	element *next;

	element(int z, element *n=NULL){
	zahl=z;
	next=n;
	}

};

class Ring{
public:
	element *head;
	Ring()
	{
		head=NULL;
	}

	void insert(int zahl);
	void display();

};

void Ring::insert(int zahl)
{
	element* help=NULL;

	if(head==NULL){
	help=new element(zahl);
	head=help;
	help->next=head;
	}

	else {
	help=new element(zahl);
	help->next=head;
	head=help;		//Head zeiger auf neues Element
	}
	cout<<help->zahl;        //Testausgabe
}

void Ring::display()
{
if(head==NULL)
	cout<<"nix da";
else
{
	element *p =head;

	while(p!=head)
	p=p->next;
	cout << p->zahl;
 }
}

int main()
{
	Ring ring1;

	ring1.insert(1);
	ring1.insert(2);
	ring1.insert(3);
	ring1.display();
}

Krieg hier nur leider als ausgabe 1233...bei meiner Testausgabe in der insert() passts...aber leider gibt er mir bei der display() nur 1x die 3 aus...warum nicht 1 und 2? Was hab ich falsch gemacht?

finix

Versuch's mal so

element* p = head;

while(p) {
  cout << p->zahl;
  p = p->next;
}

Dommel

hi moju,

als erstes würde ich die Zeile

help->next=head;

aus deiner insert-funktion löschen. Ansonsten zeigt dein letztes Element nämlich immer auf sich selber und die Liste hat keine wirkliches Ende. Wenn du die Zeile weglässt, dann zeigt dein letztes Element auf NULL und du erkennst so, wo deine Liste endet

Den else-Teil deiner display-Funktion würde ich so schreiben:

element *p =head;

while (p)
{
  cout << p->zahl;
  p=p->next;
}

Das Problem bei deiner Ausgabe ist zum Einen, dass die while-Schleife erst gar nicht betreten wirst, da du p erst auf head setzt und dann abfragst, ob p ungleich head ist, was natürlich nicht zutrifft. Also wird nur die Zeile

cout << p->zahl;

ausgeführt, da sie (anders als du es wahrscheinlich wolltest) nicht zur Schleife gehört.

hab die display jetzt geändert, aber jetzt krieg ich eine Endlosschleife die nur mehr die zahl 3 ausgibt.

warum soll ich die

help->next=head;

löschen?
wenn ich die zeile weglösche, dann gibt er mir nix aus...
ich füge ja immer ein neues element zu beginn am kopf ein. das mit dem Ende stimmt ....wie krieg ich ein schönes Ende, damit ich weiß wo die Liste endet?

lookias

am besten ist mal nur mit einer liste anzufangen die ien *next beinhaltet und einen integer

lookias

zb

class liste
{
int z;
liste *next;
};

int main()
{
liste *zeiger=0;
liste *lauf=0;
liste hilfszeiger=0;
hilfszeiger= new liste
zeiger = hilfszeiger;
lauf=zeiger;
for(int i=0;i<10;i++)
{
zeiger->z=i;
hilfszeiger=new liste;
zeiger->next=heilfszeiger;
zeiger=zeiger->next;
zeiger->next=0;
}
while(true)
{
cout<<lauf->z<<endl;
if(lauf->next==0)
break;
lauf=lauf->next;
}
}

hmm...ich würds gerne anhand meines Versuches verstehen...also was muss ich ändern, dass aus meiner liste eine funktionierende liste wird, bei der man zahlen einfügen kann? so falsch kanns ja nicht sein, oder?

lookias

verwerfen waere besser

dann neu schreiben...

eine klasse

und in der main die algorithmen fuer anfuegenund ausgeben

element(int z, element *n=NULL){
    zahl=z;
    next=n;
    }

wozu solchen konstruktor?

class Ring{
public:
    element *head;
    Ring()
    {
        head=NULL;
    }

    void insert(int zahl);
    void display();

};

unnuetze klasse?

ware besserr als elementmethode

simple anfangen dann alles checken dann weiterdenken

meine devise

elise

lookias schrieb:

verwerfen waere besser

dann neu schreiben...

eine klasse

und in der main die algorithmen fuer anfuegenund ausgeben
element(int z, element *n=NULL){
    zahl=z;
    next=n;
    }
wozu solchen konstruktor?
class Ring{
public:
    element *head;
    Ring()
    {
        head=NULL;
    }

    void insert(int zahl);
    void display();

};
unnuetze klasse?

ware besserr als elementmethode

simple anfangen dann alles checken dann weiterdenken

meine devise

enno-tyrant

mit ein paar änderungen funktioniert es soger

...
class liste
{
public:
	int z;
...
       liste *hilfszeiger=0;
...
	while(true)
	{
		if(lauf->next==0)
		break;
		cout<<lauf->z<<endl;
		lauf=lauf->next;
	}

optimieren ist besser

while(T* t=lauf->next)
    {
        //if(lauf->next==0)
        //break;
        cout<<lauf->z<<endl;
        //lauf=lauf->next; //t schon vorhanden
    }

finix

@lookias

Tip of the day: Die Gelegenheiten sinnvoll Endlosschleifen im Code unterzubringen sind rarer gesäht als man allgemein annehmen sollte.
Tip of tomorrow: if for while else - Statements generell in einen Block packen.

(Disclaimer: meine Devise )