《数据结构》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 0; //空表的情况
i = 1;                    //在非空表的情况下，p所指的是第一个节点
while(P->next)
{
p = p->next; i++;
}
return i;
}
//设L是带头节点的单链表（引入头节点概念，在后面的算法中若不加额外说明则都认为单链表是带头节点的）
int length_LinkList2(LinkList L)
{
LNode *p = L;            //p指向头节点
int i = 0;                //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 = 0;
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-1); //查找第(i-1)个节点
if(p == NULL)
{
printf("参数i错"); return 0; //第(i-1)个节点不存在，不能插入
}
else
{
s = malloc(sizeof(LNode)); //申请节点
s->data = e;
s->next = p->next;        //新节点插入在第(i-1)个节点的后面
p->next = s;
return 1;
}
}

//删除操作
//删除指针指向单链表中的节点
//（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-1); //查找第(i-1)个节点
if(p == NULL)
{
printf("第i个节点不存在"); return -1;
}
else
{
if(p->next == NULL)
{
printf("第i个节点不存在"); return 0;
}
else
{
s = p->next;        //s指向第i个节点
p->next = s->next;  //从链表中删除s
free(s);            //释放s
return 1;
}
}
}

View Code
说明：
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个节点，结束。