doppelt verketteten liste

razkwiz ,uebrigens ich bin 36...
Das ist schon was ,evilissimo vielen dank fuer Hilfe!

Entschuldigung,aber ich komme eifach nicht weiter,
wie kann mann elemente rueckwaerts ausgeben???
void rueckwaerts()

void ausgeben() {

hilfszeiger = listenanfang;

cout << hilfszeiger->name<< "\n";
cout << hilfszeiger->vorname<< "\n";

while (hilfszeiger->next != NULL) {

hilfszeiger = hilfszeiger->next;

cout << hilfszeiger->name << "\n";
cout << hilfszeiger->vorname << "\n";
}
}

void rueckwaerts() 
{
	hilfszeiger = listenende;

	cout << hilfszeiger->name<< "\n";
	cout << hilfszeiger->vorname<< "\n";

	while (hilfszeiger->prev != NULL) 
	{
		hilfszeiger = hilfszeiger->prev;

		cout << hilfszeiger->name << "\n";
		cout << hilfszeiger->vorname << "\n";
	}
}

otze

also en bissl nachdenken darfst du noch selber!

E Leute...es tut mir leid...ich kann die Liste
immer noch nich rueckwaerts ausgeben ..ja ja schon gut
also kan das jetzt bitte jemand einschreiben????BITTTEEEE

hallo, nerko, hier haste bisschen was zu knabbern:

#include <iostream>
#include <string>

using namespace std;

template<typename TElement>
class DVListe
{
	struct Element
	{
		TElement wert;
		Element *naechstes,*voriges;

		Element(TElement w, Element *n, Element *v):wert(w),naechstes(n),voriges(v) 
		{
			if(voriges!=0)
                voriges->naechstes = this;
			if(naechstes!=0)
                naechstes->voriges = this;
		}

		inline bool istErstes() const {return voriges==0;}
		inline bool istLetztes() const {return naechstes==0;}
	};

	Element *m_erstes,*m_letztes;

public:
	class ConstIterator
	{
		Element *m_element;
	public:
		ConstIterator(Element *element):m_element(element){}

		bool operator==(ConstIterator iter) const {return m_element==iter.m_element;}
		bool operator!=(ConstIterator iter) const {return !(*this==iter);}
        const TElement &operator*() const {return m_element->wert;}

		ConstIterator &operator++()     
		{ 
			m_element = m_element->naechstes;
			return *this;
		}

		ConstIterator operator++(int)
		{ 
			ConstIterator vorher = *this;
			++*this;
			return vorher;
		}

		ConstIterator& operator--()
		{ 
			m_element = m_element->voriges;
			return *this;
		}

		ConstIterator  operator--(int)
		{
			ConstIterator vorher = *this;
			++*this;
			return vorher;
		}
	};

	DVListe():m_erstes(0),m_letztes(0){}

	~DVListe()
	{
        while(!istLeer())
			reissVorneAb();
	}

	inline bool istLeer() const {return m_erstes==0;}
	inline ConstIterator erstes() const {return ConstIterator(m_erstes);}
	inline ConstIterator letztes() const {return ConstIterator(m_letztes);}
	inline ConstIterator ende() const {return ConstIterator(0);}

	inline void baueVorneDran(TElement wert)
	{
		m_erstes = new Element(wert, m_erstes, 0);
		if(m_erstes->istLetztes())
			m_letztes = m_erstes;
	}

	inline void baueHintenDran(TElement wert)
	{
		m_letztes = new Element(wert, 0, m_letztes);
		if(m_letztes->istErstes())
			m_erstes = m_letztes;
	}

	inline TElement reissVorneAb()
	{
		TElement abgerissen = m_erstes->wert;		

		if(m_erstes->istLetztes())
		{
			delete m_erstes;
			m_erstes = 0;
		}
		else
		{
            m_erstes = m_erstes->naechstes;
			delete m_erstes->voriges;
			m_erstes->voriges = 0;
		}

		return abgerissen;
	}

	inline TElement reissHintenAb()
	{
		TElement abgerissen = m_letztes->wert;

		if(m_letztes->istErstes())
		{
			delete m_erstes;
			m_erstes = 0;
		}
		else
		{
            m_letztes = m_letztes->voriges;
			delete m_letztes->naechstes;
			m_letztes->naechstes = 0;
		}

		return abgerissen;
	}
};

class Person
{
public:
    Person(string Vorname = "Karl", string Nachname = "Mustermann"):m_vorname(Vorname), m_nachname(Nachname){}

    friend ostream &operator<<(ostream &ausgabe, const Person &einePerson)
    {
		return ausgabe<<einePerson.m_vorname<<" "<<einePerson.m_nachname;
    }
private:
    string m_vorname,m_nachname;
};

int main()
{
    DVListe<Person> liste;
	DVListe<Person>::ConstIterator iterator(0);

	liste.baueHintenDran(Person());
	liste.baueHintenDran(Person("Biba", "Butzemann"));
	liste.baueVorneDran(Person("Kurt", "Sichtig"));

	cout<<"Vorwaerts:"<<endl;
	for(iterator=liste.erstes(); iterator!=liste.ende(); ++iterator)
		cout<<*iterator<<endl;

	cout<<endl<<"Rueckwaerts:"<<endl;
	for(iterator=liste.letztes(); iterator!=liste.ende(); --iterator)
		cout<<*iterator<<endl;

    cin.get();
}

wie implementiert man für eine einfachverkettete list sowas:

ConstIterator& operator--() 
        { 
            m_element = m_element->voriges; 
            return *this; 
        } 

        ConstIterator  operator--(int) 
        { 
            ConstIterator vorher = *this; 
            ++*this; 
            return vorher; 
        }

bei einer einfach_verketteten liste hat man ja nur einen zeiger auf das nächste element....hmmm

cu

otze

du brauchst noch einen zeiger auf den listenanfang, das ganze ist aber nicht zu empfehlen:

ConstIterator& operator--(){

    for(Element* temp=begin;temp->naechstes!=element;++temp);

    element = temp

    return *this;
}

@boolero
ich finds hier falsch, die lösung zu posten, die wird doch eh nur c&p...

TGGC

otze schrieb:

@boolero
ich finds hier falsch, die lösung zu posten, die wird doch eh nur c&p...

Ich bin geneigt dem zuzustimmen und begrüsse diese Haltung.

Bye, TGGC (Keine Macht den Dummen)

otze schrieb:

ich finds hier falsch, die lösung zu posten, die wird doch eh nur c&p...

Entschuldigung, das ist natürlich nicht Sinn der Sache, aber nerko schien mir so hilflos.

Er kann jetzt noch versuchen z. Bsp. folgendes zu implementieren:
-Ausgeben der Anzahl der Elemente
-Ausgeben eines Iterators an der Position eines best. Elementes
-Löschen eines best. Elementes
-Löschen der ersten n Elemente mit einem best. Wert
-Löschen aller Elemente mit einem best. Wert
-Löschen aller Elemente
-Einfügen hinter/vor einem best. Element
-Löschen und Einfügen an beliebiger Position
-Ersetzen eines best. Elementes
-Ersetzen best. Elemente
-Ersetzen an best. Position/en
...
Das mit den best. Positionen ist natürlich mit Vorsicht zu geniessen, wegen dem von vorne/hinten "durchhangeln". Der Quelltext sollte eigentlich nur als Starthilfe dienen und beim erweitern/modifizieren für weitere Funktionalitäten durchgearbeitet werden.

Übrigens, beim Postdekrement-Operator des Iterators

ConstIterator  operator--(int)

ist ein Fehler drin. Ich sag nur --

@otze:
ein

ConstIterator &operator--()

hat ja bei ner einfach verketteten liste eigentlich keinen sinn, was ich weiss hat ne einfach verkettte liste hat einfach nen forward_iterator!?
wenn man es doch braucht, dann kann es nur funktionieren, wenn man dem ConstIterator die Instanz der Liste mitgibst?!

cu