Zeigerproblem

hoelli86

Bei meinem Programm geht es um eine Liste wo Werte eingeben werden. Diese Liste wird danach mit pointer ausgegeben. Ich möchte aber die Liste wahlweise verkehrt ausgeben(die letzten Werte oben..) Bitte kann mir jemand helfen!
#include <stdio.h> // printf,gets
#include <string.h> // strcmp, strcpy
#include <conio.h> // getch(), clrscr()

typedef char string[80];
enum bool {FALSE,TRUE};

struct listenelement // DEFINITION einer
{ string s_name; // verketteten Liste
string s_ort;
struct listenelement *p_next; // Zeiger auf n„chstes Listenelement
} ;

listenelement *p_wurzel,*p; // Zeiger auf die Struktur

void listeneingabe();
void listenausgabe();
void liste_loeschen();

void main()
{ clrscr();
listeneingabe();
printf("\n\nEingabe beendet - Ausgabe mit ENTER"); getch();
listenausgabe();
liste_loeschen();
getch();
}

void listeneingabe() // EINGABE der Liste, Ablegen im HEAP
{ string eingabe;
bool fertig=FALSE;
p=p_wurzel=NULL; // mit "nichts" initialisieren
do
{
printf("\nName : ");
gets(eingabe);
if (strcmp(eingabe,"")!=0) // Es wurde etwas eingegeben
{ if (p==NULL) // Liste noch leer??
{ p = new listenelement;
p_wurzel = p; // Erdung der Liste
}
else
{ p->p_next=new listenelement; // Liste fortsetzen
p=p->p_next; // Pointer weiterbewegen
}
strcpy(p->s_name,eingabe); // eingabe-String hineinkopieren
printf("\nWohnort : ");
gets(p->s_ort); // gets = getstring
}
else // ENTER - Ende der Liste
{ p->p_next=NULL; // Ende der Liste definieren
fertig=TRUE;
}
}
while (!fertig);
}

void listenausgabe()
{
for (p=p_wurzel ; p != NULL ; p = p->p_next)
printf("\n%s %s",p->s_name,p->s_ort);

/******* dieselbe Schleife in ausfhrlicher Schreibweise:
p=p_wurzel;
while (p != NULL)
{ printf("%s\n",p->s_name);....
p = p->p_next ;
} ****************/
}

void liste_loeschen()
{
for (p=p_wurzel ; p != NULL ; p = p->p_next)
delete p; // oder: free(p);
}

Da Du eine einfach verkettet Liste hast siehe Deiner Struktur:

struct listenelement // DEFINITION einer
{ string s_name; // verketteten Liste
string s_ort;
struct listenelement *p_next; // Zeiger auf n„chstes Listenelement
};

Müsste man auf alle Fälle die Struktur so anpassen das dort
ein Zeiger auf den Vorgänger existiert:

struct listenelement // DEFINITION einer
{ string s_name; // verketteten Liste
string s_ort;
struct listenelement *p_next; // Zeiger auf n„chstes Listenelement
struct listenelement *p_prev; // Zeiger auf vorangegangenes Listenelement

};

Und nun kannst Du beim einfuegen auf einen Vorgänger verweisen.
Denk aber dran wenn noch kein Element in der Liste ist den Zeiger
auch auf NULL zu setzen. Die Liste lässt sich nun in zwei
Richtungen verketten rückwärts und vorwärts!

Nun gut jetzt kannst Du noch einen Zeiger deklarieren der immer
auf das Ende der Liste zeigt, um halt schneller dorthin zu gelangen.
Ein entsprechend deklarierter Positionszeiger (zum Navigieren in der Liste)

kann nun entweder über:

pos = pos->p_next;

oder
oder mit

pos = pos->p_prev;

gesetzt werden um auch mal was von hinten anzusehen!

mfg sclearscreen

Asgard

Ich würde das mit einer doppelt verketteten Liste machen: zusätzlich zu dem Zeiger auf das nächste Element, baust Du noch einen auf das vorherige in die Struktur ein. Dann kannst Du die Liste auch rückwärts durchlaufen.

[Edit]Da war wieder jemand schneller...[\Edit]

[ Dieser Beitrag wurde am 05.03.2003 um 22:03 Uhr von Asgard editiert. ]

Ach ja damit ichs nisch vergesse merk Dir mit einen anderen Zeiger immer
das letzte Element was eingefügt wurde, um ein neues Element was eingefügt
wird, mit diesen Zeiger zu verlinken.
Und setz dann diesen MerkerZeiger auf das neue letzte Element!
:p