《数据结构》2.3单链表（single linked list）

 //单链表节点的定义
 typedef struct node
 {
     datatype data;
     struct node *next;
 }LNode,*LinkList;            //LNode是节点类型，LinkList是指向LNode类型节点的指针类型
 LinkList H;                    //定义头指针变量

 //建立单链表（时间复杂度均为O(n)）
 //逆序建立单链表（头插法）
 LinkList Creath_LinkList()
 {
     Linklist L = NULL;        //空表
     LNode *s;
     int e;                    //设数据元素的类型为int
     scanf("%d", &e);
     while(e != flag)        //flag为设置的线性表数据元素结束标志
     {
         s = malloc(sizeof(LNode));
         s->data = e;
         s->next = L;
         L = s;
         scanf("%d", &e);
     }
     return L;
 }
 //顺序建立单链表（尾插法）
 LinkList Creatr_LinkList()
 {
     LinkList L = NULL;
     LNode *s, *r = NULL;
     int e;                    //设数据元素的类型为int
     scanf("%d", &e);
     while(e != flag)        //flag为设置的线性表数据元素结束标志
     {
         s = malloc(sizeof(LNode));
         s->data = e;
         if(L == NULL) L = s;//插入的节点是第一个节点
         else r->next = s;    //插入的节点是其他节点
         r = s;                //r恒指向新的节点
         scanf("%d", &e);
     }
     if(r != NULL) r->next = NULL;//对于非空表，尾部节点的指针于置为空指针
     return L;
 }

 //求表长（时间复杂度均为O(n)）
 //设L是不带头节点的单链表
 int length_LinkList1(LinkList L)
 {
     LNode *p = L;
     int i;                    //i是计数器
     if(p == NULL) return ; //空表的情况
     i = ;                    //在非空表的情况下，p所指的是第一个节点
     while(P->next)
     {
         p = p->next; i++;
     }
     return i;
 }
 //设L是带头节点的单链表（引入头节点概念，在后面的算法中若不加额外说明则都认为单链表是带头节点的）
 int length_LinkList2(LinkList L)
 {
     LNode *p = L;            //p指向头节点
     int i = ;                //i是计数器
     while(P->next)
     {
         p = p->next; i++;    //p所指的正是第i个节点
     }
     return i;
 }

 //查找操作（时间复杂度均为O(n)）
 //按序号查找
 LNode *Getc_LinkList(LinkList L, int i) //在单链表L中查找第i个节点，找到则返回其指针，否则返回空
 {
     LNode *p = L;            //L为头节点
     int j = ;
     while(p->next != NULL && j<i)
     {
         p = p->next; j++;
     }
     if(j == i) return p;
     else return NULL;
 }
 //按值查找
 LNode *Locate_LinkList(LinkList L,datatype e) //在单链表L中查找值为e的节点，找到后返回其指针，否则返回空
 {
     LNode *p = L->next;         //L为头节点
     while(p != NULL && p->data != e)
         p = p->next;
     return p;
 }

 //插入操作
 //在某节点之后插入节点（将*s插入*p的后面，时间复杂度为O(1)）
 s->next = p->next;
 p->next = s;                //这两条指令顺序不能改变，否则会使链表断开
 //在某节点之前插入节点（将*s插入*p的前面，时间复杂度为O(n)）
 q = L;
 while(q->next != p)
     q = q->next;            //查找*p的直接前驱*q
 s->next = q->next;
 q->next = s;
 //定位插入（把数据域值为e的节点插入链表中作为第i个节点，时间复杂度为O(n)）
 int Insert_LinkList(LinkList L, int i, datatype e) //在链表的第i个位置上插入值为e的元素
 {
     LNode *p, *s;
     p = Get_LinkList(L, i-); //查找第(i-1)个节点
     if(p == NULL)
     {
         printf("参数i错"); return ; //第(i-1)个节点不存在，不能插入
     }
     else
     {
         s = malloc(sizeof(LNode)); //申请节点
         s->data = e;
         s->next = p->next;        //新节点插入在第(i-1)个节点的后面
         p->next = s;
         return ;
     }
 }

 //删除操作
 //删除指针指向单链表中的节点
 //（1）删除*p（时间复杂度为O(n)）
 q->next = p->next;            //设查找到*p的直接前驱为*q
 free(p);
 //（2）删除*p的直接后继节点，假设其存在（时间复杂度为O(1)）
 s = p->next;                //设*p的直接后继节点为*s
 p->next = s->next;
 free(s);
 //删除单链表L的第i个节点（时间复杂度为O(n)）
 int Del_LinkList(LinkList L, int i) //删除单链表上L的第i个节点
 {
     LinkList p, s;
     p = Get_LinkList(L, i-); //查找第(i-1)个节点
     if(p == NULL)
     {
         printf("第i个节点不存在"); return -;
     }
     else
     {
         if(p->next == NULL)
         {
             printf("第i个节点不存在"); return ;
         }
         else
         {
             s = p->next;        //s指向第i个节点
             p->next = s->next;  //从链表中删除s
             free(s);            //释放s
             return ;
         }
     }
 }

说明：
1.顺序建立单链表
        由于第一个节点加入时原链表为空，它作为链表的第一个节点是没有直接前驱节点的，所以它的地址就是整个链表的起始地址，该值需要放在链表的头指针变量中；而后面再插入的其他节点都有直接前驱节点，其地址只需放入直接前驱节点的指针域即可。
2.头节点
        为了统一操作，在链表的头部加入一个特殊节点，即头节点；头节点的类型与数据节点的类型一致，标识链表的头指针变量L中存放的是头节点的地址，那么即使是空表，头指针L也不为空（其中存放着头节点的地址）；将头节点看作链表第一个节点的直接前驱，那么链表的第一个节点也有直接前驱，则无须再对第一个节点进行额外操作；
        头节点的加入使得“空表”和“非空表”的处理成为一致，其数据域无定义，指针域存放的是第一个数据节点的地址。

算法思路：
1.求表长
        设一个指针变量p和计数器i，初始化后，如果p所指节点后面还有节点，p向后移动，计数器i同时加1，直至p指向表尾。可以从单链表不带头节点和带头节点两个角度出发来设计算法（注意：计算线性表的长度时不包括头节点）。
2.查找操作
    1）按序号查找：从链表的第一个节点起，判断当前节点是否是第i个节点，若是，则返回该节点的指针，否则，根据指针域寻找下一个节点，直到表结束为止。若没有找到第i个节点，则返回空。
    2）按值查找：从链表的第一个节点起，判断当前节点数据域的值是否等于e，若等于，则返回该节点的指针，否则，根据指针域寻找下一个节点，直到表结束为止。若表中没有节点数据域的值等于e，则返回空。
3.插入操作（定位插入）
    （1）寻找第i个节点的直接前驱第(i-1)个节点，若存在，则继续第（2）步，否则结束；
    （2）申请新节点，并为其数据域赋值为e；
    （3）将新节点作为第(i-1)个节点的直接后继插入单链表中，结束。
4.删除操作（删除单链表L的第i个节点）
    （1）寻找第(i-1)个节点；若存在，则继续第（2）步，否则结束；
    （2）若存在第i个节点，则继续第（3）步，否则结束；
    （3）删除第i个节点，结束。