C++|单链表的实现源代码

#include <iostream>
using namespace std;
 
typedef struct LNode
{
       char data;
       struct LNode * next;
}LNode,* listLink;//此处声明了一个结构体类型和一个结构体类型的指针
 
/*单链表的初始化*/
void initList_L(listLink &L)
{
       L=new LNode;
       L->next=NULL;
}
 
/*清空表*/
void clearList_L(listLink &L)
{
       LNode *p,*q;
 
       p=L->next;
       L->next=NULL;//这里应该注意：L->next在等号左边和右边的含义是不一样的，在右边表示将下一个结点的地址
                    //赋值给变量，在左边表示L这个结点的地址域，是被赋值的对象。
 
 
       while (p)
       {
              q=p;
              p=p->next;
              delete q;//这里应该这样想：p和q都是指针，是指针在动，他们指向链表，而链表并没有动。
       }
}
 
/*求表长*/
int listLength_L(listLink &L)
{
       LNode *p;
       int length;
       p=L;
       length=0;
 
       while(p->next)
       {
              length++;
              p=p->next;
       }//始终遵循上面注释中说的：p和q都是指针，是指针在动，他们指向链表，而链表并没有动，这样理解就会容易很多。
 
       return length;
}
 
 
/*取第i个结点的元素值*/
char getElem_L(listLink &L,int i)
{
       LNode *p;
       int count;
 
       p=L->next;
       while(p&&count<i)
       {
              p=p->next;
              count++;
       }
       if(!p||count>i)
              cout<<"Position Error!";
       else
              return p->data;
}
 
/*确定表中某结点的地址*/
LNode *locateElem_L(listLink &L,char x)
{
       LNode *p;
       p=L->next ;
       while(p&&p->data!=x)
              p=p->next;
       if(!p)
              return NULL;
       else
              return p;
}
 
 
/*插入元素*/
void insertElem_L(listLink &L,int i,char x)
{
       LNode *p;
       LNode *s;
       int count;
 
       p=L->next;
       count=1;
 
       while(p&&count<i-1)
       {
              p=p->next;
              count++;
       }//寻找第i-1个结点，使p指向第i-1个结点。
 
       if(!p||count>i-1)
       {
              cout<<"Poision Error!";
       }
 
       else
       {
              s=new LNode;
              s->next=p->next;
              p->next=s;//注意这里赋值的顺序千万不能变，即不能这样：p->next=s; s->next=p->next;
                        //若是这样的话，就等于是先改变了p->next的值，也就不能把p的前继赋值给s了！！！
              s->data=x;
       }
}
 
/*删除表中的元素，并返回该元素的值*/
void deleteElem_L(listLink &L,int i)
{
       LNode *p,*q;
       int count;
 
       p=L->next;
       count=1;
 
       while((p->next)&&count<i-1)
       {
              p=p->next;
              count++;
       }
       if(!(p->next)||count>i-1)
              cout<<"Poision Error";
       else
       {
              q=p->next;
              p->next=q->next;
              delete q;//这里的释放就是把这个指针给销毁了，就是没有这个指针了，这也就是为什么要多一个指针的缘故。
       }
}
 
/*用正序插入法创建一个单链表*/
void creatList_L_1(listLink &L,int n)
{
       initList_L(L);
 
       LNode *p,*q;
       p=L;
 
       for(int i=0;i<n;i++)
       {
              q=new LNode;
 
              cin>>q->data;
              q->next=NULL;
 
              p->next=q;
              p=q;
 
       }
}//就是在表的尾端不断接上元素。
 
 
/*用逆序插入法创建一个单链表*/
void creatList_L_2(listLink &L,int n)
{
       initList_L(L);
 
       LNode *p;
       for(int i=0;i<n;i++)
       {
              p=new LNode;
 
              cin>>p->data;
              p->next=L->next;
              L->next=p;//不断地在L和L的前继之间插入新的元素。
       }
}//逆序法就是第一个输入的元素是单链表的最后一个元素，既是从链表的最后一个元素输入。
 
void outputList_L(listLink &L,int n)
{
       LNode *p;
       p=L->next;
 
       for(int i=0;i<n;i++)
       {
              cout<<p->data<<" ";
              p=p->next;
       }
       cout<<endl;
}//依次输出链表中的元素
 
void main()
{
       listLink L;
       //creatList_L_2(L,10);
       //outputList_L(L,10);
 
       creatList_L_1(L,10);//创建一个单链表
       //outputList_L(L,10);
 
       insertElem_L(L,2,'a');//插入
       outputList_L(L,listLength_L(L));
 
       deleteElem_L(L,11);//删除
       outputList_L(L,listLength_L(L));
}