struct T_elem
{
	unsigned key;
	T_elem *prev, *next;
};

void add_first(unsigned k)
{
	if(start==NULL)
	{
		start=stop=new T_elem;
		start->key=k;
		start->prev=start->next=NULL;
		return;	

	}

	start->prev=new T_elem;
	start->prev->next=start;//verstehe ich nicht 
	start=start->prev;
	start->key=k;
	start->prev=NULL;
}

Währe gut, wenn mir das jemand kurz erläutern kann

Gruß Georg

Wenn du vor diesem Knoten etwas einfuegen willst, musst du logischerweise start->prev auf den neuen Knoten setzen. Soweit ist es klar, oder?

aber, eine doppelt verkettete liste geht in 2 richtungen. Man kann nicht nur von start eins "prev" springen, also zurueck. Sondern auch zum "next" also naechsten Element. Jedes Element muss seinen Vorgaenger (prev) und seinen Nachfolger (next) kennen.

Deshalb muss start->prev wissen, wo start liegt.
Stellen wir uns dazu die liste a,b,c vor. a ist das erste Element und c das letzte:

null <-prev- a -next-> b
             a <-prev- b -next-> c
                       b <-prev- c -next-> null

a->prev = null
a->next = b
b->prev = a
b->next = c
c->prev = b
c->next = null

zur verwirrung:

x->prev->next == x->next->prev == x
== x->prev->prev->prev->next->next->next

Zu beginn sind start und stop NULL (Globale Zeiger auf T_elem? ). Beim Einfügen des ersten Elements in die Liste, wird eine T_elem -Instanz angelegt, auf die start und stop zeigen. Dieses Element bekommt den einzufügenden Wert.

Jedes weitere Element wird jetzt vorläufig "vor" dem Ersten ( start ) eingefügt ( start->prev = new T_elem ). Damit das neue Element auch weiß, wer sein nächster ist: start->prev->next = start; . Nun noch den start auf das neue Element setzen ( start = start->prev; ), den Wert zuweisen, und festlegen, dass start keinen Vorgänger hat start->prev = NULL; .

greetz, Swordfish

BTW: Schönes C++ ist das nicht...

... So und das kann man auch ordentlich machen

template<typename _Type>
class double_list
{
    template<typename _Type>
    struct element 
    { 
        element* m_prev; 
        element* m_next;
        _Type m_data;
        element(_Type const& data) 
            : m_prev(NULL), m_next(NULL), m_data(data)
        {}
    };

    typedef element<_Type> value_type;
    typedef std::size_t size_type;

    value_type* m_first;
    value_type* m_last;
    size_type m_size;

public:
    double_list()
        : m_first(NULL), m_last(NULL), m_size(0)
    {}

    double_list(double_list const& rhs)
    {
        if (&rhs == this) return;
        for (value_type* ptr(rhs.m_first); m_size < rhs.m_size; ptr = ptr->m_next)
            push_back(ptr->m_data);    
    }

    ~double_list()
    {
        for (value_type* ptr(m_last); m_size; --m_size)
        {
            value_type* next(ptr->m_prev);
            delete ptr;
            ptr = next;
        }
    }

    double_list& operator=(double_list const& rhs)
    { 
        if (&rhs == this) return *this;
        for (value_type* ptr(rhs.m_first); m_size < rhs.m_size; ptr = ptr->m_next)
            push_back(ptr->m_data);
    }

public:
    void push_front(_Type const& data)
    {
        if (m_first == NULL)
        { m_last = m_first = new value_type(data);  ++m_size; return; }

        m_first->m_prev = new value_type(data);
        m_first->m_prev->m_next = m_first;
        m_first = m_first->m_prev;
        ++size;
    }
    void push_back(_Type const& data)
    {
        if (m_last == NULL)
        { m_last = m_first = new value_type(data); ++m_size; return; }

        m_last->m_next = new value_type(data);
        m_last->m_next->m_prev = m_last;
        m_last = m_last->m_next;
        ++m_size;
    }
};

so ... jetzt noch schnell nen Iterator dafür schreiben und du bist fertig

Mir ist das auf jeden Fall immer viel zu doof die ganzen Randbedingungen zu checken die sich bei "normalen" doppelt verketteten Listen ergeben, daher verwende ich eigentlich nur Ringlisten (wenn ich wirklich mal eine selbstgeschriebene Liste brauche).

Vorne/hinten einfügen oder löschen geht ja noch, richtig lustig wird's dann wenn man ein beliebiges Elemtent entfernen möchte, oder an einer beliebigen Stelle etwas einfügen.

Hm. Wieso verwendet eigentlich kaum jmd. Ringlisten?

Mir ist das auf jeden Fall immer viel zu doof die ganzen Randbedingungen zu checken die sich bei "normalen" doppelt verketteten Listen ergeben, daher verwende ich eigentlich nur Ringlisten (wenn ich wirklich mal eine selbstgeschriebene Liste brauche).

Vorne/hinten einfügen oder löschen geht ja noch, richtig lustig wird's dann wenn man ein beliebiges Elemtent entfernen möchte, oder an einer beliebigen Stelle etwas einfügen.

Wie unterscheidet sich den das einfügen bzw. löschen bei Ringlisten von doppelt verketteten Listen?

Hm. Wieso verwendet eigentlich kaum jmd. Ringlisten?

Weil das mit der STL nicht ganz harmoniert. Das Problem ist: wo zeigt der end iterator hin?

Das Problem ist: wo zeigt der end iterator hin?

In meinem jugendlichen Leichtsinn, sag ich jetzt einfach mal, der zeigt auf das Element, das als Nachfolger das Start-Element hat. Zumindest habe ich das in den paar Ringlisten, die ich mal gemacht, so gelöst. Allerdings waren die nicht STL-konform.

Grüße Joe_M.

hustbaer schrieb:

Hm. Wieso verwendet eigentlich kaum jmd. Ringlisten?

Weil das mit der STL nicht ganz harmoniert. Das Problem ist: wo zeigt der end iterator hin?

na auf das dummy-element, das den ring schließt. Es liegt damit gleichzeitig vor dem ersten Element und hinter dem letzten. du warst doch auf dem forum-treffen vor zwei Jahren???

btw, mal in deine stl-implementierung reingeschaut? -- die meisten benutzen eine ringliste.

Alles klar verstanden

Danke & Gruß niesel

hustbaer schrieb:

Hm. Wieso verwendet eigentlich kaum jmd. Ringlisten?

Mir ist das auf jeden Fall immer viel zu doof die ganzen Randbedingungen zu checken die sich bei "normalen" doppelt verketteten Listen ergeben, daher verwende ich eigentlich nur Ringlisten (wenn ich wirklich mal eine selbstgeschriebene Liste brauche).

Vorne/hinten einfügen oder löschen geht ja noch, richtig lustig wird's dann wenn man ein beliebiges Elemtent entfernen möchte, oder an einer beliebigen Stelle etwas einfügen.

Wie unterscheidet sich den das einfügen bzw. löschen bei Ringlisten von doppelt verketteten Listen?

Dadurch dass man bei Ringlisten keine "ifs" braucht.

drakon schrieb:

hustbaer schrieb:

Hm. Wieso verwendet eigentlich kaum jmd. Ringlisten?

Mir ist das auf jeden Fall immer viel zu doof die ganzen Randbedingungen zu checken die sich bei "normalen" doppelt verketteten Listen ergeben, daher verwende ich eigentlich nur Ringlisten (wenn ich wirklich mal eine selbstgeschriebene Liste brauche).

Vorne/hinten einfügen oder löschen geht ja noch, richtig lustig wird's dann wenn man ein beliebiges Elemtent entfernen möchte, oder an einer beliebigen Stelle etwas einfügen.

Wie unterscheidet sich den das einfügen bzw. löschen bei Ringlisten von doppelt verketteten Listen?

Dadurch dass man bei Ringlisten keine "ifs" braucht.

- Was meinst du damit?

In eine Liste was einfügen geht ja einfach mit pusch_back () und löschen mit erase (iterator). Ok, beim löschen gibt es einen iterator, aber ich denke mal nicht, dass eine Ringliste ohne einen auskommt.

Vllt. solltest du (drakon) mal eine Liste Implementieren ... dann weißt du evtl. was er meint

- Da ist es noch nicht über den reinen Gedanken gekommen.

Ich habe es auf die Benutzung bezogen.

hustbaer schrieb:

Hm. Wieso verwendet eigentlich kaum jmd. Ringlisten?

Mir ist das auf jeden Fall immer viel zu doof die ganzen Randbedingungen zu checken die sich bei "normalen" doppelt verketteten Listen ergeben, daher verwende ich eigentlich nur Ringlisten (wenn ich wirklich mal eine selbstgeschriebene Liste brauche).

Vorne/hinten einfügen oder löschen geht ja noch, richtig lustig wird's dann wenn man ein beliebiges Elemtent entfernen möchte, oder an einer beliebigen Stelle etwas einfügen.

Und da du von verwenden gesprochen hast, bin ich davon mit meiner Frage ausgegangen.