单链表操作的实现

这次给大家带来一个单链表的C++模板实现。主要有插入（前插，后插，给定值插），删除（主要是给定值删除），倒置，等基本的操作，后续的操作会陆续做出来。

因为模板类比较特殊，分开的文件有的编译器在编译是不会出错，有的编译器会出错，因为我用的编译器，会出错，所以我把定义和实现都在一个文件中实现。

下面是主要的代码：

#include<iostream>
using namespace std;

template <class T>
class List
{
    public:
        /内部节点类，用来存储链表节点
        struct node{
            T data;
            node* next;
            node(const T data = T()):data(data),next(NULL){}               //类的构造函数
        };
        List():size(0),head(NULL){}                      //链表构造函数，也是链表初始化函数
        virtual ~List();                                 //链表析构函数，也是链表释放函数
        int insertNodeAtFront();                         //前插函数
        int insertNodeAtEnd();                           //后插函数
        int insertNodeAtData(const T&);                  //给定值插入函数
        int deleteNode(const T&);                        //给定值删除函数
        void show();                                     //显示函数
        void clear();                                    //清除函数（即链表释放函数）析构函数调用此函数
        void setNode(node*);                             //插入时调用的函数，主要用来处理两个节点插入的操作
        int getSize()const { return size;}               //得到当前链表的大小
        List<T>& reverse();                              //链表反转函数
    private:
        int size;
        node* head;
};
template <class T>
void List<T>::clear()
{
    node* p = head->next;
    while(p!=NULL)
    {
        node* temp;
        temp = p;
        p = p->next;
        --size;
        delete temp;
    }
}
template <class T>
List<T>::~List()
{
    clear();
}
template <class T>
void List<T>::setNode(node* resultNode)
{
    node* no = new node();
    if(no!=NULL){
        cout<<"Please input the data:"<<endl;
        cin>>no->data;
        no->next = resultNode->next;
        resultNode->next = no;
    }
    ++size;
}
template <class T>
int List<T>::insertNodeAtFront()
{
    int flag = 0;
    if(head==NULL)
    {
        head = new node();
    }
    setNode(head);
    return flag;
}
template <class T>
int List<T>::insertNodeAtEnd()
{
    int flag = 0;
    node* p = head->next;
    while(p!=NULL)
    {
       if(p->next==NULL)
        {
            setNode(p);
            ++flag;
            return flag;
        }
        p = p->next;
    }
}
template <class T>
int List<T>::insertNodeAtData(const T& data)
{
    int flag = 0;
    node* p = head->next;
    while(p!=NULL)
    {
       if(p->data==data)
        {
            setNode(p);
            ++flag;
        }
        p = p->next;
    }
    return flag;
}
template <class T>
int List<T>::deleteNode(const T& data)
{
    node* p = head;
    int flag = 0;
    while(p->next!=NULL)
    {
        if(p->next->data==data)
        {
            p->next=p->next->next;
            flag++;
            --size;
        }
        p = p->next;
    }

    return flag;
}
template <class T>
void List<T>::show()
{
    node* p = head->next;
    while(p!=NULL)
    {
        cout<<p->data<<' ';
        p = p->next;
    }
    cout<<endl;
}
template <class T>
List<T>& List<T>::reverse()
{
    node* p = head->next,*temp,*h = NULL,*tmp;
    while(p!=NULL)
    {
        temp = p->next;
        p->next = h;
        h = p;
        p = temp;
        tmp = h;
        while(tmp!=NULL)
        {
            cout<<tmp->data<<' ';
            tmp = tmp->next;
        }
        cout<<endl;
    }
    head->next = h;
    return *this;
}

上面是部分功能，接下来的排序，合并等等函数会陆续推出。