Двусвязные списки: функции ввода, вывода, поиска и удаления

#pragma once
 
struct Element                                 // Элемент списка 
{
    Element* Prev;                             // указатель на предыдущий элемент 
    Element* Next;                             // указатель на следующий элемент 
    void*  Data;                                   //  данные  
    Element(Element* prev, void* data, Element* next) // конструктор
    {
        Prev = prev;
        Data = data;
        Next = next;
    }
    Element* GetNext()     // получить следующий
    {
        return Next;
    };
    Element* GetPrev()     // получить предыдущий  
    {
        return Prev;
    };
};
 
struct Object                       // Блок управления списком 
{
    Element* Head;              // указатель на начало списка
    Object()
    {
        Head = NULL;
    };
    Element* GetFirst()                         // получить первый элемент списка
    {
        return Head;
    };
    Element* GetLast();                        // получить последний элемент списка
    Element* Search(void* data);       // найти  первый элемент по данным 
    bool Insert(void* data);                   // добавить элемент в начало
    bool InsertEnd(void* data);       // добавить в конец 
    bool Delete(Element* e);                  // удалить по адресу элемента 
    bool Delete(void* data);                   // удалить первый по данным
    bool Object::DeleteList(Element **list);               // очистить список 
    void Object::PrintList(void(*f)(void*));
    void Object::PrintList(void(*f)(void*), Element*);
    int Object::CountList(Element *list);
    bool  Object::DeleteDouble();
};
Object Create();                           // создать список

#include "stdafx.h"
#include "List.h"
bool Object::Insert(void* data)           // Вставка в начало
 {     bool rc=0;
        if (Head == NULL)    {      Head = new Element(NULL,data,Head);    rc = true;  }
        else     {    Head = (Head->Prev = new Element(NULL, data,Head));   rc=true;    } 
       return rc;
 }   
 Element* Object::Search (void* data)    // Найти заданный элемент
 {    Element* rc  = Head;
       while((rc != NULL) && (rc->Data != data))    
                rc = rc->Next;    
       return rc;   
 }
 void Object::PrintList(void(*f)(void*))     // Вывод
 {  Element* e = Head;
    while (e != NULL)
    {      f(e->Data);      e = e->GetNext();   };
 }
 void Object::PrintList(void(*f)(void*), Element *e)
   {    f(e->Data);     
   } 
  bool  Object::Delete(Element* e)    // Удалить по ссылке
 {     bool rc=0;
        if (rc = (e != NULL))
        {       if (e->Next != NULL)   e->Next->Prev = e->Prev; 
                 if (e->Prev != NULL)   e->Prev->Next = e->Next;
                 else   Head = e->Next; 
                 delete e;    
         }  
        return rc;
 }
  int Object::CountList(Element *list) 
  {
      int count = 0;
      Element *Prev = list;
      Element *Next = list;
      if (list != NULL)
      {
          count++;
          while (Prev->Prev != NULL)
          {
              Prev = Prev->Prev;
              count++;
          }
          while (Next->Next != NULL)
          {
              Next = Next->Next;
              count++;
          }
      }
      return count;
  }
  bool Object::DeleteList(Element **list)
  {
      Element *Next = NULL;
      if ((*list)->Next != NULL)
      {
          do
          {
              Next = (*list)->Next;
              delete *list;
              *list = Next;
          } while (Next != NULL);
      }
      return true;
  }
 bool Object::Delete(void* data)      // Удалить по значению
 {     return Delete(Search(data)); 
 };
 
  Element* Object::GetLast()
  {     Element* e = Head, *rc = e;
        while (e != NULL)
        {      rc = e; 
                e = e->GetNext();    
         };
         return rc;
  }
 
  Object Create()
  {    return *(new Object());    }

#include <iostream>
#include <cstdlib>
#include <stdint.h>
 
struct Element {
    uintptr_t ptr;
    Element*  prev;
    Element*  next;
};
 
class List {
private:
    Element* head, *tail;
    unsigned cnt;
public:
    List(void);
    ~List();
    
    bool     AddFront(uintptr_t ptr);
    bool     AddBack(uintptr_t ptr);
    Element* Insert(Element* pos, uintptr_t ptr);
    void     PopFront(void);
    void     PopBack(void);
    Element* Delete(Element* pos);
    void     Clear(void);
 
    uintptr_t Front(void) { return head->ptr; }
    uintptr_t Front(void) const { return head->ptr; }
    uintptr_t Back(void) { return tail->ptr; }
    uintptr_t Back(void) const { return tail->ptr; }
 
    Element* Head(void) const { return head; }
    Element* Head(void) { return head; }
 
    Element* Tail(void) const { return tail; }
    Element* Tail(void) { return tail; }
 
    bool     IsEmpty(void) const { return (head == NULL); }
    unsigned GetSize(void) const { return cnt; }
private:
    Element* _new_element(Element* pos, uintptr_t ptr);
    Element* _del_element(Element* pos);
};
 
 
List::List(void):head(NULL), tail(NULL), cnt(0){}
List::~List(){
    this->Clear();
}
 
//вставка в голову
bool List::AddFront(uintptr_t ptr){
    return (_new_element(head, ptr) != NULL);
}
 
//вставка в хвост
bool List::AddBack(uintptr_t ptr){
    return (_new_element(NULL, ptr) != NULL);
}
 
//вставка в произвольное место
Element* List::Insert(Element* pos, uintptr_t ptr){
    return _new_element(pos, ptr);
}
 
//удаление с головы
void List::PopFront(void){
    if(head != NULL)
        _del_element(head);
}
 
//удаление с хвоста
void List::PopBack(void){
    if(head != NULL)
        _del_element(tail);
}
 
//удаление с произвольного места
Element* List::Delete(Element* pos){
    if(head != NULL)
        pos = _del_element(pos);
    return pos;
}
 
//удаление всех
void List::Clear(void){
    Element* t;
    while(head != NULL){
        t    = head;
        head = head->next;
        delete t;
    }
    tail = NULL;
    cnt  = 0;
}
 
//создание элемента
 
Element* List::_new_element(Element* pos, uintptr_t ptr){
    Element* p = new (std::nothrow) Element();
    if(p == NULL)
        return NULL;
 
    p->ptr  = ptr;
    p->next = p->prev = NULL;
 
    if(head == NULL)
        head = tail = p;
    else {
        if(pos == head){
            p->next = head;
            head    = head->prev = p;
        } else if(pos == NULL){
            p->prev = tail;
            tail    = tail->next = p;
        } else {
            p->next   = pos;
            p->prev   = pos->prev;
            pos->prev = pos->prev->next = p;
        }
    }
    ++cnt;
    return p->next;
}
 
//удаление элемента
Element* List::_del_element(Element* pos){
    Element* p = NULL;
    if(pos == head){
        p = head = head->next;
        if(head != NULL)
            head->prev = NULL;
    } else if(pos == tail){
        p = tail = tail->prev;
        if(tail != NULL)
            tail->next = NULL;
    } else {
        p = pos->next;
        pos->prev->next = pos->next;
        pos->next->prev = pos->prev;
    }
    --cnt;
    delete pos;
 
    if((head == NULL) || (tail == NULL))
        head = tail = NULL;
    return p;
}
 
 
//печать влево и вправо
void List_Print(const List& lst){
    for(const Element* p1 = lst.Head(); p1 != NULL; p1 = p1->next)
        std::cout << (int)p1->ptr << ' ';
    std::cout << std::endl;
    
    for(const Element* p2 = lst.Tail(); p2 != NULL; p2 = p2->prev)
        std::cout << (int)p2->ptr << ' ';
    std::cout << std::endl << std::endl;
}
 
 
int main(void){
    List lst;
    for(int i = 0; i < 20; ++i)
        lst.AddFront((uintptr_t)(rand() % 10));
 
    lst.AddFront(9);
    lst.AddFront(7);
    List_Print(lst);
 
    //удалить все нечётные числа
    Element* p = lst.Head();
    while(p != NULL){
        if((int)p->ptr & 1){
            p = lst.Delete(p);
            continue;
        }
        p = p->next;
    }
    List_Print(lst);
 
    lst.AddFront(8);
    lst.AddBack(8);
 
    //вставить перед каждым числом меньше x < 6 число -1
    
    p = lst.Head();
    while(p != NULL){
        if((int)p->ptr < 6)
            p = lst.Insert(p, (uintptr_t)-1);
        p = p->next;
    }
    List_Print(lst);
    lst.Clear();
 
    //...
 
    //использование списка как очереди
    for(char c = 'A'; c <= 'Z'; ++c)
        lst.AddBack((uintptr_t)c);
 
    while(! lst.IsEmpty()){
        std::cout << (char)lst.Front();
        lst.PopFront();
    }
    std::cout << std::endl;
 
    //использование списка как стека
    for(int m = 0; m < 10; ++m)
        lst.AddBack((uintptr_t)m);
 
    while(! lst.IsEmpty()){
        std::cout << (short)lst.Back();
        lst.PopBack();
    }
    return 0;
}