本文详细介绍了链表的概念，包括单向链表和双链表的定义、基本操作及应用。对于单向链表，讲解了创建、判断空链表、查找和操作节点等；在双链表部分，讨论了创建和删除操作。此外，还探讨了链表在约瑟夫环问题和一元多项式计算中的应用。
文章目录
一、单向链表
概念
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。除了存储元素本身的信息外，还要存储其直接后继信息，因此，每个节点都包含两个部分，第一部分称为链表的数据区域，用于存储元素本身的数据信息，它不局限于一个成员数据，也可是多个成员数据，第二部分是一个结构体指针，称为链表的指针域，是存放结点的直接后继的地址（位置）的指针域（链域）
定义
typedef int DataType; /* 定义元素类型为整型，也可定义为其他类型 */
typedef struct Node { /* 单链表结点结构 */
DataType info;//结点的数据域
struct Node *next;//结点的指针域
}Node, *PNode/* 结点指针类型 */
typedef struct LinkList { /* 单链表类型定义 */
PNode head; /* 指向单链表中的第一个结点 */
}LinkList,*PLinkList; /* 单链表类型的指针类型 */
PLinkList pllist; /* pllist是指向单链表的一个指针变量 */
基本操作
1、创建一个带头结点的空链表
PLinkList createNullList_link( void )
{ PLinkList pllist;
PNode p;
pllist = (PLinkList) malloc (sizeof (struct LinkList) );
if ( pllist != NULL ) {
p = (PNode) malloc (sizeof (struct Node) );//函数malloc分配一个类型为PNode的结点变量的空间,并将其首地址放入指针变量p中
if ( p!=NULL ) {
pllist->head=p;
p->next = NULL;
}
else {
printf( "Out of space!\n" );
pllist->head = NULL;
}
}
else
printf( "Out of space!\n" );
return pllist;
}
info域–存放结点值的数据域
next域–存放结点的直接后继的地址（位置）的指针域（链域）
2、判断pllist所指的带有头结点的单链表是否是空链表
int isNullLink_link ( PLinkList pllist)
{
return ( pllist->head->next == NULL);
}
3、在带有头结点的单链表pllist中求第i个结点的位置
{ PNode p;
int j;
if (i<1) {
printf("The value of i=%d is not reasonable.\n",i);
return NULL;
}
p=pllist ->head;
for ( j=0; j<i; j++ ) {
p = p->next;
if ( p == NULL )
return NULL;
}
return p;
}
4、在pllist所指的单链表中求第一个结点的位置
PNode first_link( PLinkList pllist )
{
return pllist->head->next;
}
5、在pllist所指的单链表中求元素为x的结点位置
PNode locate_link ( PLinkList pllist, DataType x )
{
PNode p;
p = pllist->head->next;
while ( p != NULL && p->info != x )
p = p->next;
return p;
}
6、在pllist所指的单链表中求p位置上的元素
DataType retrieve_link( PNode p )
{
return p->info;
}
7、在pllist所指的单链表中求p位置的后继元素的位置
在这里插入代码片
8、在pllist所指的单链表中求元素为x的结点的前驱元素的位置
PNode previous_link( PLinkList pllist, DataType x )
{ PNode p;
p = pllist->head;
while( p->next != NULL && p->next->info != x )
p = p->next;
if ( p==pllist->head || p->next==NULL )
/* x是第一个结点的值或者不存在值为x的结点*/
return NULL;
else
return p;
}
9、在单链表中p位置的后面插入元素x
void insert_link( PLinkList pList, DataType x, PNode p )
{
PNode q;
q = (PNode)malloc( sizeof( struct Node ) );
if ( q == NULL )
printf( "Out of space!!!\n" );
else {
q->info = x;
q->next = p->next;
p->next = q;
}
}
10、在pllist所指的单链表中删除一个元素为x的结点
void delete_link( PLinkList pllist, DataType x )
{ PNode p, q;
p = pllist->head;
/* 在pllist所指的带有头结点的单链表中找元素为x的结点的前驱结点位置 */
while ( p->next != NULL && p->next->info != x )
p = p->next;
if ( p->next == NULL ) /* 没找到元素为x的结点 */
printf("Not exist!\n ");
else {
q = p->next; /* 找到元素为x的结点 */
p->next = q->next;
free( q );
}
}
11、将两个链表中数据合并并排序存放
在这里插入代码片
静态单链表
用数组描述的链表，即称为静态链表。
在C语言中，静态链表的表现形式即为结构体数组，结构体变量包括数据域data和游标cursor。
这种存储结构，仍需要预先分配一个较大的空间，但在作为线性表的插入和删除操作时不需移动元素，仅需修改指针，故仍具有链式存储结构的主要优点。
假如有如上的静态链表S中存储着线性表（a，b，c，d，f，g，h，i），Maxsize=11，要在第四个元素后插入元素e，方法是：先在当前表尾加入一个元素e，即：S[9].data = e;然后修改第四个元素的游标域，将e插入到链表中，即：S[9].cursor = S[4].cursor; S[4].cursor = 9;，接着，若要删除第7个元素h，则先顺着游标链通过计数找到第7个元素存储位置6，删除的具体做法是令S[6].cursor = S[7].cursor。
循环单链表
尾指针指向头指针，从任意结点出发均可遍历整个链表
二、双链表
概念
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。
定义
typedef struct DoubleNode{
struct DoubleNode * prior; //指向直接前趋
int data;
struct DoubleNode * next; //指向直接后继
}DoubleNode,*PDoubleNode;
基本操作
1、创建双向链表
DoubleNode* initDoubleLink(DoubleNode * head){
head=(DoubleNode*)malloc(sizeof(DoubleNode));//创建链表第一个结点（首元结点）
head->prior=NULL;
head->next=NULL;
head->data=1;
DoubleNode * list=head;
for (int i=2; i<=3; i++) {
//创建并初始化一个新结点
line * body=(DoubleNode*)malloc(sizeof(DoubleNode));
body->prior=NULL;
body->next=NULL;
body->data=i;
list->next=body;//直接前趋结点的next指针指向新结点
body->prior=list;//新结点指向直接前趋结点
list=list->next;
}
return head;
}
2、在带有头结点的双链表pllist中在第i个位置前插入元素x
void insert_dbllink(PDoubleList pdlist, int i , DataType x)
{ PDoubleNode p;
if (!(p=GetData_dbllink(pdlist, i)))
printf(“Out of range!\n”);
else
{
PDoubleNode s;
s = (P DoubleNode)malloc( sizeof( DoubleNode) );
if ( s == NULL )
printf( "Out of space!!!\n" );
else {
s->data = x;
s->prior = p->prior;
p-prior->next = s;
s->next = p;
p->prior = s;
}
}
}
3、 删除带头结点的双链表pllist中的第i个元素
void delete_dbllink(PDoubleList pdlist, int i)
{
PDoubleNode p;
if (!(p=GetData_dbllink(pdlist,i)))
printf(“Out of range!\n”);
else
{
p->llink->rlink = p->rlink;
p->rlink->llink = p->llink;
free(p);
}
}
三、链表的应用
约瑟夫环问题
已知 n 个人（以编号 1，2，3，…，n 分别表示）围坐在一张圆桌周围，从编号为 k 的人开始顺时针报数，数到 m 的那个人出列；他的下一个人又从 1 还是顺时针开始报数，数到 m 的那个人又出列；依次重复下去，要求找到最后出列的那个人。
#include <stdio.h>
#include <stdlib.h>
typedef struct node{
int number;
struct node * next;
}person;
person * initLink(int n){
person * head=(person*)malloc(sizeof(person));
head->number=1;
head->next=NULL;
person * cyclic=head;
for (int i=2; i<=n; i++) {
person * body=(person*)malloc(sizeof(person));
body->number=i;
body->next=NULL;
cyclic->next=body;
cyclic=cyclic->next;
}
cyclic->next=head;//首尾相连
return head;
}
void findAndKillK(person * head,int k,int m){
person * tail=head;
//找到链表第一个结点的上一个结点，为删除操作做准备
while (tail->next!=head) {
tail=tail->next;
}
person * p=head;
//找到编号为k的人
while (p->number!=k) {
tail=p;
p=p->next;
}
//从编号为k的人开始，只有符合p->next==p时，说明链表中除了p结点，所有编号都出列了，
while (p->next!=p) {
//找到从p报数1开始，报m的人，并且还要知道数m-1de人的位置tail，方便做删除操作。
for (int i=1; i<m; i++) {
tail=p;
p=p->next;
}
tail->next=p->next;//从链表上将p结点摘下来
printf("出列人的编号为:%d\n",p->number);
free(p);
p=tail->next;//继续使用p指针指向出列编号的下一个编号，游戏继续
}
printf("出列人的编号为:%d\n",p->number);
free(p);
}
int main() {
printf("输入圆桌上的人数n:");
int n;
scanf("%d",&n);
person * head=initLink(n);
printf("从第k人开始报数(k>1且k<%d)：",n);
int k;
scanf("%d",&k);
printf("数到m的人出列：");
int m;
scanf("%d",&m);
findAndKillK(head, k, m);
return 0;
}
一元多项式
1、一元多项式抽象数据类型的实现
typedef struct ElemType /* 二元组*/
{
float coef; /* 多项式系数 */
int expn; /* 多项式指数 */
}ElemType;
/* 结点属性 */
typedef struct Polyn
{
ElemType data; /* 数据域 */
struct Polyn *next; /* 指针域 */
}Node, *Link;
typedef struct
{
Link head, tail; /* 用作链表的结节点和尾指针 */
int len; /* 可以用来记录链表的长度 */
}LinkList,*PLinkList;
2、一元多项式的相加
PLinkList AddPolyn (PLinkList la, PLinkList lb)
{
Link pc; /* 用来指向新链表的尾结点的 */
Link hb; /* 指向第二个链表的头结点（为了最后删除它） */
Link pa; /* 指向第一个链表的当前结点 */
Link pb; /* 指向第二个链表的当前结点*/
Link temp; /* 删除结点时做临时变量用 */
ElemType a,b; /* 分别存放两个链表当前结点的数据 */
float sum; /* 存放两个链表中当前结点的系数和 */
pc = la->head;
pa = pc->next;
hb = lb->head;
pb = hb->next;
while( pa && pb)
{
a = pa->data; b = pb->data;
switch (cmp(a,b)) /*cmp(a,b)
：If a<b return -1
If a==b return 0
If a>b return 1
*/
{
case -1: /* 第一个链表中当前结点的指数值小 */
pc->next=pa; /* Link the node to the end of ha */
pc=pa; /* move the tail pointer to pa */
pa=pa->next; /* move to the next node of pa */
break;
case 0: /* 指数值相等 */
sum = a.coef + b.coef;
if ( sum != 0.0 ) {
pa->data.coef=sum;
pc->next=pa; /* Link pa to the result polyn */
pc=pa; /* Let ha still point to the tail */
pa=pa->next;
}
else { /* 释放qa所指向的结点的空间 */
temp=pa; /* pa is to be deleted, let temp point to it */
pa=pa->next; /* Let qa point to the next node */
free(temp); /* Free the space */
}
/* 释放pb所指向的结点的空间 */
temp = pb;
pb = pb->next; /* let pb point to the next node */
free(temp);
break;
case 1: /* 第一个链表中当前结点的指数值大 */
pc->next = pb;
pc = qb;
pb = pb->next;
break;
} /* End of Switch */
} /* End of while(!pa && !pb) */
pc->next = pa ? pa : pb; /* Link the rest nodes of polynomial 1 or 2 */
free(hb); /* Free the head node of the 2nd polynomial */
return (la);
} /* End of AddPolyn() */
四、线性表时间复杂度比较
扫一扫
5779
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
