单链表的C++实现。。

#include 
using namespace std;

template 
struct Node{
       Node（const T itemNode* nextnode=NULL）{data=item;next=nextnode;}
       Node（Node* nextnode=NULL）{next=nextnode;}
       T data;
       Node* next;
      };
      
template 
class List {
private:
        Node * head * tail *currptr;
        int size;
public:
       List（）;
       List（T &item）;
       ~List（）;
       bool IsEmpty（）const;
       void Insert（const T &item）;              //在当前结点后插入 
       void InsertFromTail（const T &item）;      //在头结点后插入 
       void InsertFromHead （const T &item）;    //在尾结点后插入 
       void Delete（）;                    //删除当前结点的后续结点 
       void DeleteFromHead（）;            //删除头结点 
       void DeleteFromTail（）;           //删除尾结点
       void Find（）;                        //存取当前结点值 
       void Find（int）;                     //存取指定结点值 
       int Search（const T &item）;          //返回结点下标 
	   int Getsize（）{return size;};
};

template 
List::List（）{
                head=tail=currptr=new Node（）;
                size=0;
                }
                
template 
List::List（T &item）{
                currptr=tail=new Node（item）;
                head=new Node（currptr）;
                size=1;
                }
                
template  
List::~List（）{
                 while（!IsEmpty（））{
                 currptr=head->next;
                 head->next=currptr->next;
                 delete currptr;
                 }
                 delete head;
                 }
                 
template 
bool List::IsEmpty（）const{
     if（head->next==NULL）
     return true;
     return false;
     }
                     
template 
void List::Insert（const T &item）{
	 if（currptr==NULL） return;
     currptr->next=new Node（itemcurrptr->next）;
     if（tail==currptr）
     tail=currptr->next;
     size++;
     }
     
template 
void List::InsertFromHead（const T &item）{
     if（IsEmpty（））{
                   head->next=new Node（item）;
                   currptr=tail=head->next;
                   }
     else
          head->next=new Node（itemhead->next）;
          size++;
          }

template 
void List::InsertFromTail（const T &item）{
     tail->next=new Node（item）;
     tail=tail->next;
     size++;
     }

template 
void List::Delete（）{
     if（IsEmpty（）||currptr==tail）{
     cout<<“Empty List or no next Node !“<     return ;
     }
     else{
          Node*temp=currptr->next;
          currptr->next=temp->next;
          T deldata=temp->data;
          if（currptr->next==tail）{
          tail=currptr;
          currptr->next=NULL; 
          }
          delete temp;
          size--;
          cout<<“the deleted data is : “<          }
     }
          
template 
void List::