W
T-Dragonmaster XII schrieb:
gibt es eine elegantere Lösung für das Problem, als diee von mir angegebene?
Hallo Dragon,
ja - die gibt es. Um die Reihenfolge der Elemente einer doppelt verketteten Liste umzukehren, braucht man doch nur bei jedem Element den prev- und next-Pointer auszutauschen. Das ganze sähe dann so aus:
void rev()
{
for( T_elem* p = p_list_start; p; p = p->prev )
{
std::swap( p->next, p->prev );
}
std::swap( p_list_start, p_list_stop );
}
(std::swap braucht #include <algorithm>)
Ich möchte Dir noch wärmstens empfehlen, aus Deinen Funktionen eine Klasse zu machen und die beiden globalen Pointer als Member reinzupacken.
// -- eine Liste von unsigned
class List
{
public:
List();
~List();
void add_first (unsigned);
void add_last (unsigned);
void del_first ();
void del_last ();
void print();
void rev();
private:
T_elem* p_list_start;
T_elem* p_list_stop;
// -- Kopieren vorläufig stilllegen -> Regel der Drei
List( const List& );
List& operator=( const List& );
};
das schafft Überblick. Weiter könnte man auch für so profane Strukturen wie T_elem einen Konstruktor vorsehen ...
struct T_elem
{
T_elem( unsigned k, T_elem* pr, T_elem* nx )
: key( k ), prev( pr ), next( nx )
{}
unsigned key;
T_elem * prev, * next;
};
.. dann vereinfacht sich z.B. die Methode add_first zu
void List::add_first (unsigned k)
{
T_elem* neu = new T_elem( k, 0, p_list_start );
if(!p_list_start)
{
p_list_start=p_list_stop = neu;
return;
}
p_list_start->prev = neu;
p_list_start = neu;
}
Gruß
Werner
