c++模版链表的实现

<strong><span style="font-size:18px;">#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<string>
#include<cassert>
using namespace	std;

template<typename T>
struct Node
{
    Node()
    :_next(NULL)
    {}
    ~Node()
    {
    }
public:
    T _data;
    Node* _next;

};

template <typename T>
class LinkList
{
	
public:
    LinkList();
    ~LinkList();
    LinkList(const LinkList<T> & list);
    LinkList<T>& operator =(const LinkList<T> list);
    void PushBack(const T& data);  //尾插
    void Display();
    void PushFront(const T& data);//头插
    void PopBack(); //尾删
    void PopFront();//头删
    void Insert(Node<T> *pos, const T& data);

    void Remove(const T& data);
    void RemoveAll(const T& data);
    void Sort();
    void Erase(Node<T>* pos);
    void Size();
    Node<T>* Find(const T& data);

private:
    Node<T>* _head;
    Node<T>* _tail;
};

template<typename T>
LinkList<T>::LinkList()
:_head(NULL)
, _tail(NULL)
{

}

template<typename T>
LinkList<T>::~LinkList()
{
    Node <T>*cur = _head;
    while (cur)
    {
        Node<T>*del = cur;
        cur=cur->_next;
        delete del;
    }
}

template<typename T>
LinkList<T>::LinkList(const LinkList & list)
    :_head(NULL)
    , _tail(NULL)
{
    Node <T>*cur = list._head;
    while (cur != NULL)
    {
        PushBack(cur->_data);
        cur = cur->_next;
    }

}

template<typename T>
LinkList<T>& LinkList<T>::operator =( LinkList<T> list)
{
    std::swap(_head, list._head);
    std::swap(_tail, list._tail);
    return *this;
}

template<typename T>
void LinkList<T>::PushBack(const T& data)
{
    if (_head == NULL)
    {
        _head = new Node<T>;
        _head->_data = data;
        _tail = _head;
    }
    else
    {
        Node<T> *tmp = new Node<T>;
        tmp->_data = data;
        tmp->_next = NULL;
        _tail->_next = tmp;
        _tail = tmp;
    }
}

template<typename T>
void LinkList<T>::Display()
{
    Node<T>* cur = _head;
    while (cur)
    {
        cout << cur->_data << " ";
        cur = cur->_next;
    }
    cout << endl;
}

template<typename T>
void LinkList<T>::PushFront(const T& data)
{
    Node<T>*tmp = new Node<T>;
    tmp->_data = data;
    Node <T>*cur = _head;
    _head = tmp;
    tmp->_next = cur;
}


template<typename T>
void LinkList<T>::PopBack()
{
    Node <T>*cur = _head;
    Node <T>*del = NULL;
    if (_head == NULL)
    {
        return;
    }
    else if (_head == _tail)
    {
        del = _head;
        delete del;
        _head = _tail = NULL;
    }
    else
    {
        while (cur->_next != _tail)
        {
            cur = cur->_next;
        }
        delete _tail;
        _tail = cur;
        _tail->_next = NULL;

    }
}

template<typename T>
void LinkList<T>::PopFront()
{
    if (_head == NULL)
    {
        return;
    }
    else
    {
        Node<T>* cur = _head;
        Node<T>* del = NULL;
        del = _head;
        _head = _head->_next;
        delete del;
        del = NULL;
    }
}
template<typename T>
Node<T>* LinkList<T>::Find(const T& data)
{
    Node<T>* cur = _head;
    while (cur)
    {
        if (cur->_data == data)
        {
            return cur;
        }
        cur = cur->_next;
    }
    return NULL;
}
template<typename T>
void LinkList<T>::Insert(Node<T>* pos, const T& data)
{
    if (pos == NULL)
    {
        return;
    }
    Node<T>* newnode = new Node<T>;
    newnode->_data = data;
    Node<T>* cur = _head;
    Node<T>* prev = NULL;
    while (cur != NULL)
    {
        if (pos == cur)
        {
            break;
        }
        prev = cur;
        cur = cur->_next;
    }
    if (prev == NULL)
    {
        _head->_next = newnode;
        newnode->_next = cur;
    }
    else
    {
        prev->_next = newnode;
        newnode->_next = cur;
    }
}

template<typename T>
void LinkList<T>::Remove(const T& data)
{
    if (_head == NULL)
    {
        return;
    }
    Node<T> *cur = _head;
    Node<T> *prev = NULL;
    Node<T> *del = NULL;
    while (cur != NULL)
    {
        if (cur->_data == data)
        {
            if (cur == _head)
            {
                del = cur;
                _head = cur->_next;
                delete del;
                del = NULL;
            }
            else
            {
                del = cur;
                prev->_next = cur->_next;
                delete del;
                del = NULL;
            }
            return;
        }
        else
        {
            prev = cur;
            cur = cur->_next;
        }
    }
}

template<typename T>
void LinkList<T>::RemoveAll(const T& data)
{
    if (_head == NULL)
    {
        return;
    }
    Node<T> *cur = _head;
    Node<T> *del = NULL;
    Node<T> *prev = cur;
    while (cur != NULL)
    {
        if (cur->_data == data)
        {
            if (cur == _head)
            {
                del = cur;
                prev = cur->_next;
                _head = cur->_next;
                delete del;
                del = NULL;
            }
            else
            {
                del = cur;
                prev->_next = cur->_next;
                delete del;
                del = NULL;
            }
            cur = prev;
        }
        else
        {
            prev = cur;
            cur = cur->_next;
        }
    }
}

template<typename T>
void LinkList<T>::Sort()
{
    if ((_head == NULL) || (_head->_next == NULL))
    {
        return;
    }
    Node<T>* cur = _head;
    Node<T>* tail = NULL;
    while (cur != tail)
    {
        while (cur->_next != tail)
        {
            if (cur->_data > cur->_next->_data)
            {
                std::swap(cur->_data, cur->_next->_data);
            }
            cur = cur->_next;
        }
        tail = cur;
        cur = _head;
    }
}

template<typename T>
void LinkList<T>::	Erase(Node<T>* pos)
{
    if (_head == NULL)
    {
        return;
    }
    Node<T> *cur = _head;
    Node<T> *del = NULL;
    Node<T> *prev = _head;
    while (cur != NULL)
    {
        if (pos == cur)
        {
            if (pos == _head)
            {
                del = pos;
                _head = cur->_next;
                delete del;

                del = NULL;
            }
            else
            {
                del = pos;
                prev->_next = cur->_next;
                delete del;
                del = NULL;
            }
            return;
        }
        else
        {
            prev = cur;
            cur = cur->_next;
        }


    }
}

template<typename T>
void LinkList<T>::Size()
{
    Node<T>*cur = _head;
    int count = 0;
    while (cur != NULL)
    {
        count++;
        cur = cur->_next;
    }
    cout<<count<<endl;
}

int main()
{
	LinkList<int> l;
	/*l.PushFront(1);
	l.PushFront(2);
	l.PushFront(3);
	l.PushFront(4);*/
	//l.Display();
	l.PushBack(4);
	l.PushBack(3);
	l.PushBack(2);
	l.PushBack(1);
	l.PushBack(1);
	l.Display();
	l.Size();
	//l.Remove(1);
	//l.Display();
	l.RemoveAll(1);
	l.Display();
	system("pause");
	return 0;
}</span></strong>