Verkettete Liste

Hier eine einfach verkettete Liste die sich beim ausgeben der Daten aufhängt.
Womöglich eine nichtgewollte Endlosschleife, in der Funktion "ElementeAusgeben()".
Außerdem würde ich gerne wissen ob mein kurzes Programm Memory Leaks verursachen würde, also ob ich das Löschen der Elemente richtig gemacht habe.

#include <iostream.h>

struct Knoten
{
	int x;
	int y;

	Knoten *pNachfolger;
};

Knoten Listenkopf;

void NeuesElement(int x, int y);
void ElementeLoeschen(void);
void ElementeAusgeben(void);

void main()
{
	int i=0;
	int x=0;
	int y=0;

	cout << "Daten fuer den Listenkopf eingeben\n";
	cout << "x: "; cin >> Listenkopf.x; cout << '\n';
	cout << "y: "; cin >> Listenkopf.y; cout << '\n';

	Listenkopf.pNachfolger = NULL;

	while(x>=0)
	{
		cout << "x: ";
		cin >> x;
		cout << '\n';

		if(x>=0)
		{
			cout << "y: ";
			cin >> y; cout << '\n';

			NeuesElement(x,y);
		}
	}

	ElementeAusgeben();
	ElementeLoeschen();
}

void NeuesElement(int x, int y)
{
	Knoten* Element = new Knoten;

	Element->x = x;
	Element->y = y;
	Element->pNachfolger = NULL;

	Knoten* p = &Listenkopf;

	while(p->pNachfolger != NULL)
	{
		p = p->pNachfolger;
	}

	p->pNachfolger = Element;
}

void ElementeAusgeben(void)
{
	Knoten* p = &Listenkopf;

	while(p->pNachfolger != NULL)
	{
		p = p->pNachfolger;
		cout << "x: " << p->x << '\n';
		cout << "y: " << p->y << '\n';

	}
}

void ElementeLoeschen(void)
{
	while(NULL != Listenkopf.pNachfolger)
	{
		Knoten* p = &Listenkopf;
		Knoten* pp = NULL;

		while(p->pNachfolger != NULL)
		{
			p = p->pNachfolger;
		}

		pp = p->pNachfolger;
		delete pp;
		p->pNachfolger = NULL;
	}
}

akari

Hallo

wegen dem Aufhängen :

Wenn du den Nachfolger von p bestimmst, gibst du dessen Wert aus, auch wenn der NULL ist. du mußt das umdrehen

while(p != NULL)
    {
        cout << "x: " << p->x << '\n'; 
        p = p->pNachfolger;

     }

bis bald
akari

finix

@soner
Schon mal daran gedacht das alles in eine Klasse zu packen wenn du schon C++ benutzt? Als Template? Oder einfach std::list zu verwenden?

[edit]

void ElementeLoeschen(void)
{
  Knoten* p1 = Listenkopf.pNachfolger;
  Knoten* p2;

  while (p1 != NULL) {
    p2 = p1;
    p1 = p1->pNachfolger;
    delete p2;
  }
}

[/edit]

akari schrieb:

Wenn du den Nachfolger von p bestimmst, gibst du dessen Wert aus, auch wenn der NULL ist.

Listenkopf ist ein dummy & existiert immer, oder nicht?

Der Listenkopf wird global deklariert, er existiert somit immer ja und objekt orientiert habe ich noch nicht programmiert.
kommt noch

enno-tyrant

Soner schrieb:

...objekt orientiert habe ich noch nicht programmiert...

so? und was ist dann 'struct' ?

zumindest ein anfang

camper

finix' code ist nat. besser, nochmal zur illustration:

void ElementeLoeschen(void)
{
    while(NULL != Listenkopf.pNachfolger)
    {
        Knoten* p = &Listenkopf;
        Knoten* pp = NULL;

        while(p->pNachfolger != NULL)
        {
            p = p->pNachfolger;
        }

        pp = p->pNachfolger;
        delete pp;
        p->pNachfolger = NULL;
    }
}

überleg mal welchen wert pp zugewiesen bekommt.
du wolltest sicher so etwas schreiben:

void ElementeLoeschen(void)
{
    while(NULL != Listenkopf.pNachfolger)
    {
        Knoten* p = &Listenkopf;
        Knoten* pp = Listenkopf->pNachfolger;

        while(pp->pNachfolger != NULL)
        {
            p = pp;
            pp = pp->pNachfolger;
        }

        delete pp;
        p->pNachfolger = NULL;
    }
}

ist nat. trotzdem schrecklich ineffizient.

so und nun die üblichen sachen:
es heisst

int main()

void main ist nicht und war noch nie legal, weder in C++ noch in standard C noch in pre-standard C.

#include <iostream>

das sind die standardheader. der bequemlichkeit halber gefolgt von einem

using namespace std;