双向链表

#include<iostream>
#include<assert.h>
using namespace std;

typedef int DataType;
class LinkNode
{
    friend class List;
public:
    LinkNode(const DataType& x)
    :_data(x)
    ,_prev(NULL)
    ,_next(NULL)
    {}
private:
    DataType _data;
    LinkNode* _prev;
    LinkNode* _next;
};

class List
{
public:
    List() :_Head(NULL), _Tail(NULL)
    {}
    List(const List& l)
    {}
    ~List()
    {}
    List& operator=(const List &l)
    {}
public:
    void Print()
    {
        LinkNode* begin = _Head;
        while (begin)
        {
            cout << begin->_data << "<->";
            begin = begin->_next;
        }
        cout << "NULL" << endl;
    }
    void PushBack(const DataType& x) //尾插
    {
        //1.没有节点
        //2.多个节点
        if (_Head == NULL)
        {
            _Head = new LinkNode(x);
            _Tail = _Head;
        }
        else
        {
            LinkNode* tmp = new LinkNode(x);
            _Tail->_next = tmp;
            tmp->_prev = _Tail;
            _Tail = tmp;
        }
    }

    void PopBack()
    {
        if (_Head == NULL)
        {
            return;
        }
        if (_Head == _Tail)
        {
            delete _Head;
            _Head = NULL;
            _Tail = NULL;
        }
        else
        {
            LinkNode* del = _Tail;
            _Tail = _Tail->_prev;
            delete del;
            _Tail->_next = NULL;
        }
    }

    void PushFront(const DataType& x)
    {
        //1.没有节点
        //2.多个节点
        if (_Head == NULL)
        {
            _Head = new LinkNode(x);
            _Tail = _Head;
        }
        else
        {
            LinkNode* tmp = new LinkNode(x);
            tmp->_next = _Head;
            _Head->_prev = tmp;
            _Head = tmp;
        }
    }

    void PopFront()
    {
        if (_Head == NULL)
        {
            return;
        }
        if (_Head == _Tail)
        {
            delete _Head;
            _Head = NULL;
            _Tail = NULL;
        }
        else
        {
            LinkNode* del = _Head;
            _Head = _Head->_next;
            delete del;
            _Head->_prev = NULL;
        }
    }

    LinkNode* Find(const DataType& x)
    {
        LinkNode* begin = _Head;
        while (begin)
        {
            if (begin->_data == x)
            {
                cout << "find " << x << endl;
                return begin;
            }
            begin = begin->_next;
        }
        cout << "not find " << x << endl;
        return NULL;
    }
    void Insert(LinkNode* pos, const DataType& x) //在pos的后面插入x
    {
        assert(pos);

        LinkNode* begin = _Head;
        while (begin)
        {
            LinkNode* tmp = new LinkNode(x);
            if (begin == pos)
            {
                if (pos == _Tail)
                {
                    pos->_next = tmp;
                    tmp->_prev = pos;
                    _Tail = tmp;
                }
                else
                {
                    tmp->_prev = pos;
                    tmp->_next = pos->_next;
                    pos->_next = tmp;
                    tmp->_next->_prev = tmp;
                }
            }
            begin = begin->_next;
        }
    }

    void Erase(LinkNode* del)
    {
        assert(del);
        if (_Head == NULL)
        {
            return;
        }
        LinkNode* begin = _Head;
        while (begin)
        {
            if (begin == del)
            {
                if (_Head == _Tail)  //只有一个节点
                {
                    delete del;
                    _Head = NULL;
                    _Tail = NULL;
                    return;
                }
                if (del == _Head)  //删头节点
                {
                    _Head = _Head->_next;
                    delete del;
                    _Head->_prev = NULL;
                    return;
                }
                if (del == _Tail)  //删尾节点
                {
                    _Tail = _Tail->_prev;
                    delete del;
                    _Tail->_next = NULL;
                    return;
                }
                else  //删中间节点
                {
                    del->_prev->_next = del->_next;
                    del->_next->_prev = del->_prev;
                    delete del;
                    return;
                }
            }
            begin = begin->_next;
        }
    }
private:
    LinkNode* _Head;
    LinkNode* _Tail;
};

void Test()
{
    List l1;
    l1.PushBack(1);
    l1.PushBack(2);
    l1.PushBack(3);
    l1.Print();
    l1.PopBack();
    l1.PopBack();
    l1.PopBack();
    /*l1.PopBack();*/
    l1.Print();
}

void Test2()
{
    List l1;
    l1.PushFront(1);
    l1.PushFront(2);
    l1.PushFront(3);
    l1.Print();
    LinkNode* node = l1.Find(4);
    l1.Erase(node);
    /*l1.Insert(node, 4);*/
    l1.Print();
    //l1.PopFront();
    //l1.PopFront();
    //l1.PopFront();
    //l1.PopFront();
    //l1.Print();
}

int main()
{
    Test2();
    getchar();
    return 0;
}