双向链表的简单实现丶

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

struct ListNode
{
    ListNode* _next;
    ListNode* _prev;
    DataType _data;

    ListNode(DataType x)
        :_next(NULL)
        , _prev(NULL)
        , _data(x)
    {}
};

class List
{
    typedef ListNode Node;
public:
    List()
        :_head(NULL)
        , _tail(NULL)
    {}
    List(const List& l)
        :_head(NULL)
        , _tail(NULL)
    {
        Copy(l);
    }

    void Copy(const List& l)
    {
        Node* cur = l._head;
        while (cur)
        {
            PushBack(cur->_data);
            cur = cur->_next;
        }
    }
    List& operator=(const List& l)
    {
        Node* cur = _head;
        while (_head)
        {
            cur = _head;
            _head = _head->_next;
            delete cur;
        }
        _head = _tail = NULL;
        Copy(l);
        return *this;
    }
    ~List()
    {
        Node* cur = _head;
        while (cur)
        {
            Node* del = cur;
            cur = cur->_next;
            delete del;
        }

        _head = _tail = NULL;
    }

    void PushBack(DataType x)
    {
        if (NULL== _tail)
        {
            _head = _tail = new Node(x);
        }
        else
        {
            Node* tmp = new Node(x);
            _tail->_next = tmp;
            tmp->_prev = _tail;
            _tail = tmp;
        }
    }
    void PopBack()
    {
        Erase(_tail);
    }
    void PushFront(DataType x)
    {
        if (_head == NULL)
        {
            _head = _tail = new Node(x);
        }
        else
        {
            Node* tmp = new Node(x);
            tmp->_next = _head;
            _head->_prev = tmp;
            _head = _head->_prev;
        }
    }
    void PopFront()
    {
        Erase(_head);
    }
    // 在pos的前面插入一个
    void Insert(Node* pos, DataType x)
    {
        //assert(pos);
        if (pos == _head)
        {
            Node* tmp = new Node(x);
            tmp->_next = _head;
            _head->_prev = tmp;
            _head = tmp;
        }
        else
        {
            Node* cur = pos;
            Node* tmp = new Node(x);
            Node* prev = cur->_prev;
            prev->_next = tmp;
            tmp->_next = cur;
            cur->_prev = tmp;
            tmp->_prev = prev;
        }
    }
    void Erase(Node* pos)
        // 1.只有一个节点
        // 2.头删
        // 3.尾删
        // 4.中间删
    {
        assert(pos);
        Node* prev = pos->_prev;
        Node* next = pos->_next;
        if (prev == NULL && next == NULL)
        {
            assert(pos == _head);
            _head = _tail = NULL;
        }
        else if (prev == NULL)
        {
            _head = next;
            _head->_prev = NULL;
        }
        else if (next == NULL)
        {
            _tail = prev;
            _tail->_next = NULL;
        }
        else
        {
            prev->_next = next;
            next->_prev = prev;
        }
        delete pos;
    }
    Node* Find(DataType x)
    {
        Node* cur = _head;
        while (cur)
        {
            if (cur->_data == x)
            {
                return cur;
            }
            cur = cur->_next;
        }
        return NULL;
    }
    void Reverse()
    {
        Node* cur = _head;
        while (cur)
        {
            swap(cur->_next, cur->_prev);
            cur = cur->_prev;
        }
        swap(_head, _tail);
    }
    void Print()
    {
        Node* cur = _head;
        while (cur)
        {
            cout << cur->_data << " ";
            cur = cur->_next;
        }
        cout << endl;
    }

private:
    Node* _head;
    Node* _tail;
};