Преобразовать односвязный список в двусвязный

//------вспомогательный класс-------//
class elemspiska
{public:
void* data;
elemspiska* next;
elemspiska* prev;
};
//---класс односвязный список
class spisok {
public:
spisok():h(0){}  // 0 означает пустой список
~spisok() {release (); }
void prepend(void* c); //добавление в голову списка
void del();       //Удаляет первый обьект
elemspiska* first() const { return h;}  //указатель на первый объект
void release();
void print(TMemo* M);
void sort(int i);
protected:
elemspiska* h ;//Голова списка
  };
 
void spisok::print(TMemo* M){}
void spisok::prepend(void* c){
elemspiska* temp = new elemspiska; //Создание элемента
temp -> next = h; //связь с slist
temp -> data = c;
h = temp; //измение головы списка
}
 
void spisok::del(){
elemspiska* temp = h;
h = h -> next; //предполагается не пустой slist
delete temp;
}
 
void spisok::release(){
while (h != 0)
del();
}

#pragma once
 
#define NULL 0
 
template <class T>
class Table
{
    struct node                     
    {
        T item;
        node* next;
        node* previous;
    };
 
public:
 
    node* tail;                 
    node* head;                 
    node* iterator;
    int nodes_count;            
 
    Table(void) : nodes_count(0)
    {
        tail = NULL;
        head = NULL;
        iterator = NULL;
    }
 
    ~Table(void)
    {
    }
 
    template <class T> int length()
    {
        return nodes_count;
    }
 
    template <class T> bool empty()
    {
        if(!nodes_count) return 1;
        return 0;
    }
 
    template <class T> bool insert_node(T r)
    {
        node* temp_previous;
        node* temp_next;
 
        node* appendNode = new node;
 
        if(!appendNode) return 0;
 
        if(iterator)
        {
            temp_previous = iterator->previous;
            temp_next = iterator;
            
            if(iterator == tail)
            {
                tail = appendNode;
            }
 
            iterator = appendNode;
            temp_next->previous = iterator;
            iterator->next = temp_next;
            iterator->previous = temp_previous;
            if(appendNode != tail)temp_previous->next = iterator;
            iterator->item = r;
 
            if(nodes_count == 1) 
            {
                tail = iterator;
                iterator->next = head;
            }
 
            nodes_count++;
 
            delete temp_next;
            delete temp_previous;
        }
        else
        {
            iterator = appendNode;
            iterator->next = NULL;
            iterator->previous = NULL;
            iterator->item = r;
            tail = appendNode;
            head = appendNode;
            nodes_count++;
        }
 
        return 1;
    }
 
    template <class T> bool append_node(T r)
    {
        node* appendNode = new node;
 
        head;
        tail;
 
        if(!appendNode) return 0;
        
        appendNode->item = r;
        appendNode->previous = NULL;
        tail->previous = appendNode;
        appendNode->next = tail;
        tail = appendNode;
 
        nodes_count++;
 
        return 1;
    }
 
    template <class T> bool first_node()
    {
        if(head) 
        {
            iterator = head;
            return 1;
        }
        return 0;
    }
 
    template <class T> bool last_node()
    {
        if(tail) 
        {
            iterator = tail;
            return 1;
        }
        return 0;
    }
 
    template <class T> bool next_node()
    {
        if(iterator->next) 
        {
            iterator = iterator->next;
            return 1;
        }
        return 0;
    }
 
    template <class T> bool previous_node()
    {
        if(iterator->previous) 
        {
            iterator = iterator->previous;
            return 1;
        }
        return 0;
    }
 
    template <class T> bool delete_node(T r)
    {
        node* temp_previous;
        node* temp_next;
 
        iterator = head;
 
        if(tail->item == r)
        {
            temp_next = tail;
            tail = tail->next;
            delete temp_next;
            return 1;
        }
 
        if(nodes_count)
        {
            do 
            {
                if(iterator->item == r) 
                {
                    if(iterator == tail) tail = iterator->next;
                    if(nodes_count > 1)
                    {
                        // verschieben Zeiger auf Head oder auf Tail
                        // wenn Element Firat oder Last ist
                        if(!iterator->next) 
                        {
                            head = iterator->previous;
                        }
                        if(!iterator->previous)
                        {
                            tail = iterator->next;
                        }
 
                        temp_previous = iterator->previous;
                        temp_next = iterator->next;
                        if(temp_previous != NULL)temp_previous->next = temp_next;
                        if(temp_next != NULL)temp_next->previous = temp_previous;
 
                        delete iterator;
                        nodes_count--;
 
                        iterator = tail;
                        return 1;
                    }
                    else
                    {
                        head = NULL;
                        tail = NULL;
                        delete iterator;
                        nodes_count--;
                        return 1;
                    }
                    
                }
                iterator = iterator->previous;
            }
            while(iterator != tail);
        }
        return 0;
    }
 
 
    template <class T> bool get_node(T r)
    {
        iterator = head;
 
        do 
        {
            if(iterator->item == r) return 1;
            iterator = iterator->previous;
        }
        while(iterator != tail);
 
        return 0;
    }
 
 
    template <class T> bool set_node(T r, T wert)
    {
        iterator = head;
 
        do 
        {
            if(iterator->item == r)
            {
                iterator->item = wert;
                return 1;
            }
            iterator = iterator->previous;
        }
        while(iterator != tail);
 
        return 0;
    }
 
    template <class T> T get_item()
    {
        if(iterator) return iterator->item;
    }
};

    struct node                     
    {
        T item;
        node* next;
        node* previous;
    };
 
public:
 
    node* tail;                 
    node* head;                 
    node* iterator;
    int nodes_count;