单链表C++实现

//线性表的链式存储结构
////线性表的第一个元素的地址为线性表的头指针
////尾指针尾空
///*
//头指针：
//1.头指针是指链表指向第一个节点的指针，若链表有头结点则是指向头结点的指针
//2.头指针具有标识作用，所以常用头指针冠以链表的名字
//3.头指针是链表的必要元素
//头结点：
//1：头结点是为了操作统一和方便而设立的，放在第一个元素的结点之前，其数据域一般无意义
//(也可存放链表长度)
//2：有了头结点，对在第一个元素前插入结点和删除第一结点其操作就和其他结点操作统一了
//3：头结点不一定是链表必要的元素*/
#include<iostream>
#define ElemType int
using namespace std ;

struct LNode
{
    ElemType data ;    //数据域
    struct LNode *next ; //指针域
};      //linklist 是结构体指针类型  

class linklist
{
    public:
            linklist() ; //构造函数
            ~linklist() ;        
            bool linkEmpty();
            void clearList();
            int  linkLength();
            ElemType GetElem(int i);
            int  locateElem(ElemType e);
            bool priorElem(int cur_e,ElemType *pre_e);
            bool nextElem(int cur_e,ElemType *next_e);
            bool InsertElem(int i , ElemType e);
            bool deleteElem(int i , ElemType e);
            LNode *Reverse() ;    
    private:
            LNode *head ; //     
        
};
linklist::linklist()
{
    head = NULL ;    
}

linklist::~linklist()
{
    LNode *p = head ;
    while(head)
    {
        p = head ;
        head = head->next ;
        delete []p;
    }    
}
int linklist::linkLength()
{
    LNode *p = head ;
    int i = 0 ;
    while (p!=NULL)
    {
        i++ ;
        p = p->next ;
    }
    return i ;
}
ElemType linklist::GetElem(int i )
{
    LNode *p = head;
    ElemType e ;
    while(i--)
    {
        p = p->next ;
    }
    e = p->data ;
    //return p.e ;
    return e ;
        
}
bool linklist::InsertElem(int i , ElemType e)
{
    LNode *p = head ,*s; // p 是一个指向结点类型的地址
    
    int j = 0 ;
    if (i == 0)
    {
        s = new LNode[1] ;
        s->data = e ;
        s->next = p ;
        head     = s ;
        return true ;
    
    }
    while (p&&j< i - 1)
    {
        p=p->next ;
        j++ ;
    }
    if(p == NULL)
    {
        return false ;
    }
    s= new LNode[1] ;
    s->data = e ;
    s->next = p->next ;    
    p->next = s ;    

    return true ;
}

bool linklist::linkEmpty()
{
    LNode *p = head ;
    int len = 0 ;
    while(p !=NULL )
    {
        p = p->next ;
        len++ ;    
    }
    if(len == 0)
    {
        return true ;
    }
    else
    {
        return false ;
    }
}

int linklist::locateElem(ElemType e)  //按值查找
{
    LNode *p = head ;
    int i = 0;
    while(p->data != e)
    {
        p = p->next    ;
        i++    ;
    }
    return i ;
}
bool linklist::deleteElem(int i , ElemType e)
{
    LNode *p = head ,*s = NULL;
    int j = 0 ;
    while(p!=NULL&&j < i-1)
    {
        p=p->next ;
        j++ ;
    }

    s = p->next ;
    p->next = s->next ;
    e = s->data ;
    delete s;
    return true ;    
}
LNode* linklist::Reverse()
{
    if(head == NULL||head->next==NULL)
    return head ;
    LNode *p = head,*q,*r;
    q = head->next ;
    head->next= NULL ;    
    while(q)
    {
            
        r = q->next ;
        q->next = p ;
        p    = q     ;
        q    = r     ;
        
    }
        
    head = p ;
    return head ;
}

int main()
{
    linklist li ;
    ElemType *p ;
    li.InsertElem(0 , 10);
    li.InsertElem(1 , 11);    
    li.InsertElem(2 , 12);
    li.InsertElem(3 , 13);
    li.InsertElem(4 , 14);
    li.InsertElem(5 , 15);    
    cout<<"链表长度："<<li.linkLength()<<endl ;
    //遍历链表
    for(int i = 0 ; i<li.linkLength();i++)
    {

        cout<< li.GetElem(i)<<" " ;
    }
    cout << endl ;
    cout<<"反转链表后的元素："<<endl ;
    LNode* re_li = li.Reverse() ;
    while (re_li)
    {
        cout<<re_li->data<<" " ;
        re_li = re_li->next ;
        
    }
    cout <<endl ;
    system("pause");
}