Zeigerkonstruktion á la next->next

Gugi

xD kann man das nicht schon langsam flamewar nennen?^^

also, meine Code-Fassung:

/*##########################
     Einsendeaufgabe 5.2
  ##########################*/
#include <iostream>

using namespace std;

// Definition des Typs für die Elemente der Liste als Struktur
struct listenelement {
 char daten[10];
 listenelement* next; // vorwärts
 listenelement* last; // rückwärts
};

// Zeiger auf Anfang der Liste
listenelement* listenanfang;
listenelement* listenende;

// Funktion zum Einfügen von Elementen in die Liste
void einfuegen(char datenneu[30]) 
{
 // Es wird angenommen, dass listenanfang ungleich NULL ist!!!!
 listenelement* hilfszeiger = listenanfang;
 listenelement* hilfszeiger_rueck = NULL;

 while(hilfszeiger->next != NULL)
   hilfszeiger = hilfszeiger->next;

 listenelement* NeuesListenelement = new(listenelement);

 hilfszeiger->next = NeuesListenelement;

 // listenende erhält das aktuelle (letzte) Element
 listenende = NeuesListenelement;

 // Daten im neuen Element eintragen
 strcpy(NeuesListenelement->daten, datenneu);

 hilfszeiger->next = NULL;
 NeuesListenelement->last = hilfszeiger; // Verknüpfe neues Objekt mit altem
}

// Alle Elemente der Liste ausgeben
void ausgeben() 
{
 if (listenanfang == NULL)
   return;

 listenelement* hilfszeiger = listenanfang;

 while(hilfszeiger != NULL)
 {
  cout << hilfszeiger->daten << '\n';
  hilfszeiger = hilfszeiger->next;
 }
}

// Initialisieren der Liste
void init() 
{
 // erstes Element erzeugen
 listenanfang = new(listenelement);

 // Daten in das erste Element schreiben
 listenanfang->next   = NULL;
 listenanfang->last   = NULL;
 strcpy(listenanfang->daten, "Element 0");
}

// Liste leeren und Speicher freigeben
void ende() 
{
 listenelement* hilfszeiger = NULL;

 // Solange noch Elemente in der Liste sind
 while(listenanfang != NULL) 
 {
  // hilfszeiger auf das erste Element der Liste
  hilfszeiger = listenanfang;

  // Zeiger für den Listenanfang auf das nächste Element setzen
  listenanfang = listenanfang->next;

  // Das herausgenommene Element löschen
  delete(hilfszeiger);
 }
}

// Elemente rückwärts ausgeben
void ausgaberueckwaerts() 
{
 listenelement* hilfszeiger_rueck = listenende;

 while(hilfszeiger_rueck != NULL)
 {
  cout << hilfszeiger_rueck->daten << '\n';
  hilfszeiger_rueck = hilfszeiger_rueck->last;
 }
}

int main() 
{
 init();
 einfuegen("Element 1");
 einfuegen("Element 2");
 einfuegen("Element 3");
 ausgeben();
 ausgaberueckwaerts();
 ende();

 return 0;
}

Wichtigste Änderungen:
- Die 2 globalen Variablen wurden entfernt (warum brauchst du die???? warum MÜSSEN die global sein, warum können sie nicht lokal sein, was besser wäre).
- Zeile 26: Schleife wurde korrigiert
- Zeile 40: last wird jetzt korrekt initialisiert
- Die Schleifen in ausgeben() und ausgaberueckwaerts() wurden geändert, so dass die gesamte Ausgabe innerhalb der Schleife erfolgt (nicht wie bei deiner Version, wo das 1. Element vorher ausgegeben wurde).

Aber warum erstellst du den Listenanfang in der Init() Funktion? Warum nicht einfach den Fall, dass der Listenanfang == NULL ist, in der Einfüge() Funktion behandeln? Dann bräuchtest du die Init() funktion gar nicht, die meines erachtens eh unsinnig ist (du musst dann nur dann am Beginn von main() listenanfang und listenende gleich NULL setzten!).

Also entweder verstehst du die Theorie nicht, oder du verstehst den Code nicht, den du geschrieben hast^^ Eines von beiden, weil, und da bin ich mir ziemlich sicher, dein jetziger Code falsch ist.

finix

Gugi schrieb:

Übrigens nennt man ein Element einer solchen Liste Knoten (also ist eigtl. deine struktur-Bezeichnung falsch).

Wie kommst du denn auf diese unsinnige Idee?

Gugi

naja, hab ich so gelernt (aus einem Buch).
Außerdem: http://www.google.de/search?hl=de&q=verkettete+Liste+Knoten&btnG=Google-Suche&meta=

Egal, ich fand nur "liste" als Struktur-Namen etwas eigenartig (weil die Struktur ja nicht die Liste ansich ist, sondern weil es ein Element der Liste repräsentiert).

Mh, wie heißt so ein Element der Liste dann?

Wenn "die Struktur ja nicht die Liste ansich ist", dann heißt so ein Element der Liste Liste.

Zeigerkonstruktion á la next-&gt;next

Zeigerkonstruktion á la next->next