C++单链表

1.头文件
#ifndef __LINKLIST_H_
#define __LINKLIST_H_
#include <iostream>
using namespace std;


template<class T>
struct LinkList
{
    T data;
    LinkList<T> *next;
};
//
template<class T>
class LinkListClass
{
public:
    LinkListClass<T>();
    ~LinkListClass<T>();
    void CreateListF(T a[], int n);//头插法，构造单链表
    void CreateListR(T a[], int n);//尾插法，构造单链表
    void DisPlay();
    int ListLength();
    bool GetElem(int i, T &e);
    int LocateElem(T e);
    bool ListInsert(int i, T e);
    bool ListDelete(int i);
    void Sort();
    template<class C> friend int FindLast(LinkListClass<C>&L, C x);//查找最后一个值为x的结点的逻辑序号
    template<class C> friend void Reverse(LinkListClass<C>&L);//逆置单链表对象中的所有结点
    template<class C> friend void Merge(LinkListClass<C>&L1, LinkListClass<C>&L2, LinkListClass<C>&L3);//二路归并
private:
    LinkList<T> *head;
};
//
template<class T>
LinkListClass<T>::LinkListClass()
{
    head = new LinkList<T>();
    head->next = NULL;
}
//
template<class T>
LinkListClass<T>::~LinkListClass()
{
    LinkList<T> *p,*pre;
    pre = head;         //pre指向头结点，p指向其后继结点
    p=pre->next;
    while(p!=NULL)
    {
        delete pre;     //释放前一个结点
        pre = p;
        p = p->next;    //pre,p同步后移
    }
    delete pre;         //当p=NULL时，pre指向尾结点，且需释放尾结点


}
//
template<class T>
void LinkListClass<T>::CreateListF(T a[],int n)
{
    LinkList<T> *p,*s;
    s = new LinkList<T>;
    s->data = a[0];
    s->next = NULL;
    for(int i = 1; i<n; ++i)
    {
        p = s;
        s = new LinkList<T>;
        s->data = a[i];
        s->next = p;
        head->next = s;
    }
}
//
template<class T>
void LinkListClass<T>::CreateListR(T a[], int n)
{
    LinkList<T> *p,*s;
    s = head;
    for(int i=0; i!=n; ++i)
    {
        p = new LinkList<T>;
        p->data = a[i];
        p->next = NULL;
        s->next = p;
        s = p;
    }
}
//
template<class T>
void LinkListClass<T>::DisPlay()
{
    LinkList<T> *p;
    p = head->next;
    while( p!=NULL )
    {
        cout<<p->data<<"  ";
        p=p->next;
    }
    cout<<endl;
}
//
template<class T>
int LinkListClass<T>::ListLength()
{
    int length = 0;
    LinkList<T> *p;
    p = head->next;
    while( p!=NULL )
    {
        ++length;
        p = p->next;
    }
    return length;
}
//
template<class T>
bool LinkListClass<T>::GetElem( int i, T &e )
{
    LinkList<T> *p;
    p = head;
    for(int j=0; j!=i; ++j)
    {
        p = p->next;
    }
    if(p == NULL)
    {
        return false;
    }
    else
    {
        e = p->data;
        return true;
    }
}
//
template<class T>
int LinkListClass<T>::LocateElem(T e)
{
    LinkList<T> *p;
    int locate = 1;
    while( p->data!= e )
    {
        ++locate;
        p = p->next;
    }
    if( p->next = NULL )
    {
        return 0;
    }
    else
    {
        return locate;
    }
}
//
template<class T>
bool LinkListClass<T>::ListInsert( int i, T e)
{
    LinkList<T> *s,*p;
    p->data = e;
    s = head;
    for(int j=0; j!=i-1; ++j)
    {
        s = s->next;
    }
    p->next = s->next;
    s->next = p;
    return true;
}
//
template<class T>
bool LinkListClass<T>::ListDelete( int i)
{
    LinkList<T> *p,*s;
    int j = 0;
    while((j<i-1)&&(s!=NULL))
    {
        s = s->next;
    }
    if( s == NULL )
    {
        return false;
    }
    else
    {   p = s->next;
        s->next = p->next;
        delete p;
        return true;
    }
}
//
template<class T>
void LinkListClass<T>::Sort()
{


}
//
template<class C>
int FindLast( LinkListClass<C>&L, C x )
{
    LinkList<C> *p;
    p = L.head->next;
    int i=0, j;
    while(p!=NULL)
    {
        ++i;
        if( p->data== x )
        {
            j=i;
        }
        p = p->next;
    }
    return j;
}
//
template<class C>
void Reverse(LinkListClass<C>&L)
{
    LinkList<C> *p,*q;
    p = L.head->next;
    L.head->next = NULL;
    while(p!=NULL)              //采用头插法将p结点插入到head之后
    {
        q = p->next;
        p->next = L.head->next;
        L.head->next = p;
        p = q;
    }
}
//
template<class C>
void Merge( LinkListClass<C>&L1, LinkListClass<C>&L2, LinkListClass<C>&L3 )
{
    LinkList<C> *p, *q, *s, *r;
    p = L1.head->next;
    q = L2.head->next;
    s = L3.head;
    while( (p!=NULL)&&(q!=NULL))
    {
        if((p->data)>(q->data))
        {
            r = new LinkList<C>;
            r->data = q->data;
            r->next = NULL;
            s->next = r;
            s = r;
        }
        else
        {
            r = new LinkList<C>;
            r->data = p->data;
            r->next = NULL;
            s->next = r;
            s = r;
        }
    }
    while( p!=NULL )
    {
        r = new LinkList<C>;
        r->data = p->data;
        r->next = NULL;
        s->next =r;
        s = r;
        p = p->next;
    }
    while( q!=NULL )
    {
        r = new LinkList<C>;
        r->data = q->data;
        r->next = NULL;
        s->next =r;
        s = r;
        q = q->next;
    }
}

#endif // __LINKLIST_H_

2.主函数

#include "LinkList.h"


int main()
{
    int a[]={2,4,6,8};
    LinkListClass<int> Link1;
    LinkListClass<int> Link2;
    Link1.CreateListR(a,4);
    Link2.CreateListF(a,4);
    Link1.DisPlay();
    Link2.DisPlay();


    Link1.ListInsert(2,7);
    Link1.DisPlay();


    cout<<Link1.ListLength()<<endl;


    return 0;
}