第二章线性表——单线性链式的基本操作（4）
作者：互联网
1 建立单链表
动态地建立单链表的常用方法有如下两种：头插入法，尾插入法。
⑴ 头插入法建表
从一个空表开始，重复读入数据，生成新结点，将读入数据存放到新结点的数据域中，
然后将新结点插入到当前链表的表头上，直到读入结束标志为止。即每次插入的结点都作为链表的第一个结点。
1 算法描述：头插法
2 以32767作为结束标志。
3 LNode *create_LinkList(void)
4 /* 头插入法创建单链表,链表的头结点head作为返回值 */
5 { int data ;
6 LNode *head, *p;
7 head= (LNode *) malloc( sizeof(LNode));
8 head->next=NULL; /* 创建链表的表头结点head */
9 while (1)
10 { scanf(“%d”, &data) ;
11 if (data==32767) break ;
12 p= (LNode *)malloc(sizeof(LNode));
13 p–>data=data; /* 数据域赋值 */
14 p–>next=head–>next ; head–>next=p ;
15 /* 钩链，新创建的结点总是作为第一个结点 */
16 }
17 return (head);
18 }
(2) 尾插入法建表
头插入法建立链表虽然算法简单，但生成的链表中结点的次序和输入的顺序相反。
若希望二者次序一致，可采用尾插法建表。该方法是将新结点插入到当前链表的表尾，使其成为当前链表的尾结点。
1 算法描述
2 LNode *create_LinkList(void)
3 /* 尾插入法创建单链表,链表的头结点head作为返回值 */
4 { int data ;
5 LNode *head, *p, *q;
6 head=p=(LNode *)malloc(sizeof(LNode));
7 p->next=NULL; /* 创建单链表的表头结点head */
8 while (1)
9 { scanf(“%d”,& data);
10 if (data==32767) break ;
11 q= (LNode *)malloc(sizeof(LNode));
12 q–>data=data; /* 数据域赋值 */
13 q–>next=p–>next; p–>next=q; p=q ;
14 /*钩链，新创建的结点总是作为最后一个结点*/
15 }
16 return (head);
17 }
无论是哪种插入方法，如果要插入建立的单线性链表的结点是n个，算法的时间复杂度均为O(n)。
对于单链表，无论是哪种操作，只要涉及到钩链(或重新钩链)
，如果没有明确给出直接后继，钩链(或重新钩链)的次序必须是“先右后左”。
2 单链表的查找
(1) 按序号查找 取单链表中的第i个元素。
对于单链表，不能象顺序表中那样直接按序号i访问结点，而只能从链表的头结点出发，沿链域next逐个结点往下搜索，直到搜索到第i个结点为止。
因此，链表不是随机存取结构。
设单链表的长度为n，要查找表中第i个结点，仅当1≦i≦n时，i的值是合法的。
1 算法描述
2 ElemType Get_Elem(LNode *L ， int i)
3 { int j ; LNode *p;
4 p=L->next; j=1; /* 使p指向第一个结点 */
5 while (p!=NULL && j<i)
6 { p=p–>next; j++; } /* 移动指针p , j计数 */
7 if (j!=i) return(-32768) ;
8 else return(p->data);
9 /* p为NULL 表示i太大; j>i表示i为0 */
10 }
11 移动指针p的频度：
12 i<1时：0次; i∈[1,n]：i-1次；i>n：n次。
13 ∴时间复杂度: O(n)。
(2) 按值查找
按值查找是在链表中，查找是否有结点值等于给定值key的结点?
若有，则返回首次找到的值为key的结点的存储位置；否则返回NULL。查找时从开始结点出发，
沿链表逐个将结点的值和给定值key作比较。
1 算法描述
2 LNode *Locate_Node(LNode *L，int key)
3 /* 在以L为头结点的单链表中查找值为key的第一个结点 */
4 { LNode *p=L–>next;
5 while ( p!=NULL&& p–>data!=key) p=p–>next;
6 if (p–>data==key) return p;
7 else
8 { printf(“所要查找的结点不存在!!\n”);
9 retutn(NULL);
10 }
11 }
12 算法的执行与形参key有关，平均时间复杂度为O(n)。
3 单链表的插入
插入运算是将值为e的新结点插入到表的第i个结点的位置上，
即插入到ai-1与ai之间。因此，必须首先找到ai-1所在的结点p，
然后生成一个数据域为e的新结点q，q结点作为p的直接后继结点。
1 算法描述
2 void Insert_LNode(LNode *L，int i，ElemType e)
3 /* 在以L为头结点的单链表的第i个位置插入值为e的结点 */
4 { int j=0; LNode *p，*q;
5 p=L–>next ;
6 while ( p!=NULL&& j<i-1)
7 { p=p–>next; j++; }
8
9 if (j!=i-1) printf(“i太大或i为0!!\n ”);
10 else
11 { q=(LNode *)malloc(sizeof(LNode));
12 q–>data=e; q–>next=p–>next;
13 p–>next=q;
14 }
15 }
16 设链表的长度为n，合法的插入位置是1≦i≦n。算法的时间主要耗费移动指针p上，故时间复杂度亦为O(n)。
4 单链表的删除
⑴ 按序号删除 删除单链表中的第i个结点。 为了删除第i个结点ai，必须找到结点的存储地址。
该存储地址是在其直接前趋结点ai-1的next域中，
因此，必须首先找到ai-1的存储位置p，然后令p–>next指向ai的直接后继结点，即把ai从链上摘下。
最后释放结点ai的空间，将其归还给“存储池”
算法描述
void Delete_LinkList(LNode *L， int i)
/* 删除以L为头结点的单链表中的第i个结点 */
{ int j=1; LNode *p，*q;
p=L; q=L->next;
while ( p->next!=NULL&& j<i)
{ p=q; q=q–>next; j++; }
if (j!=i) printf(“i太大或i为0!!\n ”);
else
{ p–>next=q–>next; free(q); }
}
⑵ 按值删除
删除单链表中值为key的第一个结点。
与按值查找相类似，首先要查找值为key的结点是否存在? 若存在，则删除；否则返回NULL。
算法描述
void Delete_LinkList(LNode *L，int key)
/* 删除以L为头结点的单链表中值为key的第一个结点 */
{ LNode *p=L, *q=L–>next;
while ( q!=NULL&& q–>data!=key)
{ p=q; q=q–>next; }
if (q–>data==key)
{ p->next=q->next; free(q); }
else
printf(“所要删除的结点不存在!!\n”);
}
算法的执行与形参key有关，平均时间复杂度为O(n)。
从上面的讨论可以看出，链表上实现插入和删除运算，无需移动结点，仅需修改指针。
解决了顺序表的插入或删除操作需要移动大量元素的问题。
变形之一： 删除单链表中值为key的所有结点。
与按值查找相类似，但比前面的算法更简单。
基本思想：从单链表的第一个结点开始，对每个结点进行检查，若结点的值为key，则删除之，然后检查下一个结点，直到所有的结点都检查。
1 void Delete_LinkList_Node(LNode *L，int key)
2 /* 删除以L为头结点的单链表中值为key的第一个结点 */
3 { LNode *p=L, *q=L–>next;
4 while ( q!=NULL)
5 { if (q–>data==key)
6 { p->next=q->next; free(q); q=p->next; }
7 else
8 { p=q; q=q–>next; }
9 }
10 }
变形之二： 删除单链表中所有值重复的结点，使得所有结点的值都不相同。
与按值查找相类似，但比前面的算法更复杂。
基本思想：从单链表的第一个结点开始，对每个结点进行检查：检查链表中该结点的所有后继结点，
只要有值和该结点的值相同，则删除之；然后检查下一个结点，直到所有的结点都检查。
1 算法描述
2 void Delete_Node_value(LNode *L)
3 /* 删除以L为头结点的单链表中所有值相同的结点 */
4 { LNode *p=L->next, *q, *ptr;
5 while ( p!=NULL) /* 检查链表中所有结点 */
6 { *q=p, *ptr=p–>next;
7 /* 检查结点p的所有后继结点ptr */
8 while (ptr!=NULL)
9 { if (ptr–>data==p->data)
10 { q->next=ptr->next; free(ptr);
11 ptr=q->next; }
12 else { q=ptr; ptr=ptr–>next; }
13 }
14 p=p->next ;
15 }
16 }
5 单链表的合并（了解即可）
设有两个有序的单链表，它们的头指针分别是La 、 Lb，
将它们合并为以Lc为头指针的有序链表。合并前的示意图如图2-4所示。
合并了值为-7，-2的结点后示意图如图2-5所示。
算法说明 算法中pa ，pb分别是待考察的两个链表的当前结点，pc是合并过程中合并的链表的最后一个结点。
1 LNode *Merge_LinkList(LNode *La， LNode *Lb)
2 /* 合并以La, Lb为头结点的两个有序单链表 */
3 { LNode *Lc, *pa , *pb , *pc, *ptr ;
4 Lc=La ; pc=La ; pa=La->next ; pb=Lb->next ;
5 while (pa!=NULL && pb!=NULL)
6 { if (pa->data<pb->data)
7 { pc->next=pa ; pc=pa ; pa=pa->next ; }
8 /* 将pa所指的结点合并，pa指向下一个结点 */
9 if (pa->data>pb->data)
10 { pc->next=pb ; pc=pb ; pb=pb->next ; }
11 /* 将pa所指的结点合并，pa指向下一个结点 */
12 if (pa->data==pb->data)
13 { pc->next=pa ; pc=pa ; pa=pa->next ;
14 ptr=pb ; pb=pb->next ; free(ptr) ; }
15 /* 将pa所指的结点合并，pb所指结点删除 */
16 }
17 if (pa!=NULL) pc->next=pa ;
18 else pc->next=pb ; /*将剩余的结点链上*/
19 free(Lb) ;
20 return(Lc) ;
21 }
22 算法分析
23 若La ，Lb两个链表的长度分别是m，n，则链表合并的时间复杂度为O(m+n) 。
标签：结点,单链,LNode,next,链表,链式,基本操作,data,线性表 来源： https://www.cnblogs.com/kx-bk/p/15799208.html