Lista jednokierunkowa uporządkowana - Pytanie o implementacje

#include <iostream>
#include <cstdlib>

using namespace std;

class List_Orderliness
{
    float key; // Wartosc
    List_Orderliness * next; // Nastepnik
    List_Orderliness * previous; // Poprzednik
    bool Empty; // Czy lista jest pusta
   
public:
    void Print(); // Wyswietlenie zawartosci listy.
    void Add( float x ); // Dodanie i automatyczne poprawne umiejscowienie elementu na liscie
    List_Orderliness(); // Konstruktor
    float Take_First(); // Pobranie z listy pierwszego elementu - czyli wartosci zawsze najmniejszej
};

List_Orderliness::List_Orderliness() // Konstruktor domniemany
{
    key = 0;
    next = 0;
    previous = 0;
    Empty = 1;
}

void List_Orderliness::Add( float x ) // Dodanie i automatyczne poprawne umiejscowienie elementu na liscie
{
    if( next == 0 && previous == 0 && Empty == 1 ) // Gdy lista jest pusta.
    {
        key = x;
        Empty = 0;
        return;
    }
   
    List_Orderliness * new_argument = new List_Orderliness;
    List_Orderliness * wsk = this;
    List_Orderliness * wsk_backup = this;
   
    while( true )
    {
        if( wsk_backup->next == 0 ) // Gdy mamy doczynienia z ostatnim elementem listy (lub jedynym)
        {
            wsk_backup->next = new_argument;
            wsk_backup = wsk_backup->next;
            wsk_backup->key = x;
            wsk_backup->previous = wsk;
            break;
        }
       
        wsk = wsk->next; // wsk wskazuje na kolejny element
       
        if( wsk_backup->key > x ) // Jesli poprzedni element jest wiekszy od wartosci wkladanej na liste
        {
            wsk->previous = new_argument;
            new_argument->next = wsk;
            new_argument->key = wsk_backup->key;
            new_argument->previous = wsk_backup;
            wsk_backup->next = new_argument;
            wsk_backup->key = x;
            break;
        }
       
        if( x <= wsk->key ) // Jesli wstawiana wartosc jest mniejsza lub rowna nastepnemu elementowi
        {
            wsk->previous = new_argument;
            wsk_backup->next = new_argument;
            new_argument->previous = wsk_backup;
            new_argument->next = wsk;
            new_argument->key = x;
            break;
        }
       
        if( x > wsk->key ) // Jesli wstawiana wartosc jest wieksza niz nastepny element
        {
            if( wsk->next == 0 )
            {
                wsk->next = new_argument;
                new_argument->previous = wsk;
                new_argument->key = x;
                break;
            }
            else
                 wsk_backup = wsk;
           
        }
    }
}

void List_Orderliness::Print() // Wyswietlenie zawartosci listy.
{
    cout << "===============================" << endl;
    List_Orderliness * wsk = this;
    if( this->Empty == 1 )
    {
        cout << "Lista jest pusta." << endl;
        cout << "===============================" << endl;
        return;
    }
    for( int i = 1;; i++ )
    {
        cout << "Element " << i << " = " << wsk->key << endl;
        if( wsk->next == 0 )
             break;
       
        wsk = wsk->next;
    }
    cout << "===============================" << endl;
}

float List_Orderliness::Take_First() // Pobranie z listy pierwszego elementu - czyli wartosci zawsze najmniejszej.
{
   
    float tmp = this->key;
    if( Empty == 1 )
    {
        cout << "Lista jest pusta, zwracam 0." << endl;
        return 0.0;
    }
   
    if( this->next == 0 ) // Prawda - znaczy ze mamy doczynienia z ostatnim elementem na liscie.
    {
        this->key = 0;
        Empty = 1;
        return tmp;
    }
    else
    {
        List_Orderliness * wsk = this->next;
        if( wsk->next == 0 ) // Prawda - znaczy, ze mamy doczynienia z przedostatnim skladnikiem na liscie.
        {
            this->key = wsk->key;
            this->next = wsk->next;
            delete wsk;
            return tmp;
        }
        else
        {
            List_Orderliness * wsk2 = this->next;
            this->key = wsk->key;
            this->next = wsk->next;
            wsk = wsk->next;
            wsk->previous = this;
            delete wsk2;
            return tmp;
        }
    }
}

int main()
{
    List_Orderliness obiekt;
   
    obiekt.Add( 3 );
    obiekt.Add( 4 );
    obiekt.Add( 5 );
    obiekt.Add( 10 );
    obiekt.Add( 6 );
    obiekt.Add( 6 );
    obiekt.Add( 6 );
    obiekt.Add( 2 );
    obiekt.Add( 3 );
    obiekt.Add( 1 );
    obiekt.Add( 6 );
    obiekt.Add( 3.6 );
    obiekt.Add( - 2 );
    obiekt.Add( - 3.33390 );
    obiekt.Add( 10000 );
    obiekt.Add( - 10000 );
    obiekt.Add( 13 );
   
    obiekt.Print();
   
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
    obiekt.Take_First();
   
    obiekt.Print();
   
    obiekt.Add( 54 );
    obiekt.Add( 324 );
    obiekt.Add( 1 );
    obiekt.Add( - 666 );
   
    obiekt.Print();
   
    system( "PAUSE" );
    return 0;