本文详细介绍了链表的基础知识，包括单向链表的创建（有头指针，无头结点和有头指针、头结点的情况），双向链表的创建，以及循环链表的构建。文中还提供了C语言实现的示例代码，便于理解链表的操作。此外，文章还探讨了链表中判断环和链表相交的问题及其解决方案。
1、单向链表
（1）创建有头指针，无头结点的单向链表:
#include<stdio.h>
#include<malloc.h>
struct LNode
{
int data;
struct LNode *next;
};
struct LNode *creat(int n)
{
int i;
struct LNode *head,*p1,*p2; /*head用来标记链表，p1总是用来指向新分配的内存空间，p2总是指向尾结点，并通过p2来链入新分配的结点*/
int a;
head=NULL;
for(i=1;i<=n;i++)
{
p1=(struct LNode *)malloc(sizeof(struct LNode));
printf("请输入链表中的第%d个数：",i);
scanf("%d",&a);
p1->data=a;
if(head==NULL)/*指定链表的头指针*/
head=p1;
else
p2->next=p1;
p2=p1;
p2->next=NULL; /*尾结点的后继指针为NULL(空)*/
}
return head;/*返回链表的头指针*/
}
void main()
{
int n;
struct LNode *q;
printf("请输入链表的长度：/n");
scanf("%d",&n);
q=creat(n); /*链表的头指针(head)来标记整个链表*/
printf("/n链表中的数据：/n");
while(q)/*直到结点q为NULL结束循环*/
{
printf("%d ",q->data); /*输出结点中的值*/
q=q->next; /*指向下一个结点*/
}
}
（2）创建有头指针、头结点的单向链表：
/*-----------------------------------------------------------------------------
文件功能:实现了动态建立一个学生信息的链表包括链表的
创建、插入、删除、和打印输出学生信息包括姓名和分数
本链表是带有头结点的，头结点的内容为空内容
-----------------------------------------------------------------------------*/
/*-------------------------包含头文件------------------------------------*/
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
/*-------------------------结构体定义部分------------------------------*/
struct Node
{
char name[10];
int score;
struct Node *next;
};
typedef struct Node ListNode;
/*----------------------------函数声明部分------------------------------*/
/*---------------------------函数实现部分-------------------------------*/
/*-----------------------------创建链表---------------------------------*/
/*在链表的末端插入新的节点，建立链表*/
ListNode *CreateList(int n)
{
ListNode *head;//指向头结点指针
ListNode *p,*pre;
int i;
head=(ListNode *)malloc(sizeof(ListNode));//为头节点分配内存空间
head->next=NULL;//将头结点的指针域清空
pre=head;//先将头结点首地址赋给中间变量pre
for(i=1;i<=n;i++)//通过for循环不断加入新的结点
{
printf("input name of the %d student:",i);//打印出第几个人的名字
p=(ListNode *)malloc(sizeof(ListNode));//为要插入的节点分配
//内存空间p指向新插入结点的首地址
scanf("%s",&p->name);//输入姓名
printf("input score of the %d student:",i);
scanf("%d",&p->score);//输入分数
pre->next=p;//将p指向新结点插入链表也就是头结点指针域指向
//下个结点
//第一个结点就是p指向的，因为头结点内容为空
pre=p;//这个起着指向下一个结点的作用
}
p->next=NULL;//最后将最后一个结点的指针域清空了
return head;//返回这个链表的首地址
}
/*-------------------------输出链表-----------------------------------*/
void PrintList(ListNode *h)
{
ListNode *p;
p=h->next;
while(p)
{
printf("%s,%d",p->name,p->score);
p=p->next;
printf("\n");
}
}
/*----------------------插入链表结点--------------------------*/
/*--------------------------------------------------------------------
函数名称:InsertList(ListNode *h,int i,char name[],int e,int n)
函数功能:插入链表结点
入口参数: h: 头结点地址 i:插入到第几个结点 name:插入
结点的姓名 e:插入结点的分数 n:
链表中结点的个数
除下头结点外的个数
出口参数:
--------------------------------------------------------------------*/
void InsertList(ListNode *h,int i,char name[],int e,int n)
{
ListNode *q,*p;//先定义2个指向一个结点的指针
int j;
if(i<1 || i>n+1)
printf("Error! Please input again.\n");
else
{
j=0;
p=h;//将指针p指向要链表的头结点
while(j<i-1)
{
p=p->next;
j++;
}
q=(ListNode *)malloc(sizeof(ListNode)); /*为要插入的结点分配内存空间*/
//----赋值操作---------
strcpy(q->name,name); //将名字拷到要插入的节点内
q->score=e; //将要插入的节点中分数赋值
//调整指针域
q->next = p->next; /*这个是将新插入的结点指针域指向
上一个结点指针域指向的结点地址即为p->next*/
p->next=q; /*将要插入结点位置前面的结点指针域指向现在插入的结点首地址*/
}
}
/*--------------------------------------------------------------------
函数名称:DeleteList(ListNode *h, int i, int n)
函数功能:删除链表结点
入口参数: h: 头结点地址 i:要删除的结点所在位置
n:
链表中结点的个数除下头结点外的个数
出口参数:
--------------------------------------------------------------------*/
void DeleteList(ListNode *h, int i, int n)
{
ListNode *p,*q;//首先定义2个指向结点型结构体的指针
int j;
char name[10];
int score;
if(i<1 || i>n) //如果位置超出了1和n的范围的话则打印出错误信息
printf("Error! Please input again.\n");
else //没有超出除头结点外的1到n 的范围的话那么执行删除操作
{
j=0;
p=h; //将指针指向链表的头结点首地址
while(j<i-1)
{
p=p->next;
j++;
}
q=p->next; /*q指向要删除的位置之前的那个结点指针域指向的
地址q指向的结点就是要删除的结点*/
p->next=q->next; /*这个就是将要删除的结点的前面那个结点
的指针域指向要删除的结点指针域中存放的下个结点的
首地址从而实现了删除第i个结点的作用*/
strcpy(name,q->name);
score=q->score;
free(q);//释放q指向的结点
printf("name=%s,score=%d\n",name,score);
}
}
/*--------------------------主函数-------------------------------*/
void main()
{
ListNode *h;//h指向结构体NODE
int i = 1, n, score;
char name [10];
while ( i )
{
/*输入提示信息*/
printf("1--建立新的链表\n");
printf("2--添加元素\n");
printf("3--删除元素\n");
printf("4--输出当前表中的元素\n");
printf("0--退出\n");
scanf("%d",&i);
switch(i)
{
case 1:
printf("n="); /*输入创建链表结点的个数*/
scanf("%d",&n);
h=CreateList(n);/*创建链表*/
printf("list elements is : \n");
PrintList(h);
break;
case 2:
printf("input the position. of insert element:");
scanf("%d",&i);
printf("input name of the student:");
scanf("%s",name);
printf("input score of the student:");
scanf("%d",&score);
InsertList(h,i,name,score,n);
printf("list elements is:\n");
PrintList(h);
break;
case 3:
printf("input the position of delete element:");
scanf("%d",&i);
DeleteList(h,i,name,score,n);
printf("list elements in : \n");
PrintList(h);
break;
case 4:
printf("list element is : \n");
PrintList(h);
break;
case 0:
return;
break;
default:
printf("ERROR!Try again!\n");
}
}
}
2、创建双向链表
程序分析：双向链表的结点有两个指针域，一个指向其直接后继，另一个指向其直接前驱。其中第一个结点的前驱为NULL（头结点为第0个结点），最后一个结点的后继为NULL。
代码如下：
#include<stdio.h>
#include<string.h>
#include<malloc.h>
typedef struct node
{
char name[20];
struct node *prior,*next;
}stud;
/*双链表的结构定义*/
stud *creat(int n)/*创建双链表函数*/
{
stud *p,*h,*s;
int i;
h=(stud *)malloc(sizeof(stud));/*动态分配内存赋予头结点*/
h->name[0]='/0';/*为头结点的内容置空*/
h->prior=NULL;/*头结点的前驱和后继置为NULL*/
h->next=NULL;
p=h;/*将头结点赋值于p，p总是指向链表的最后一个结点*/
for(i=0;i<n;i++)
{
s=(stud *)malloc(sizeof(stud)); /*动态分配内存*/
p->next=s; /*让p结点的后继指向s*/
printf("请输入第%d个同学的名字：",i+1);
scanf("%s",s->name);
s->prior=p; /*让s结点的前驱指向p结点*/
s->next=NULL; /*让s结点的后继指向NULL，s总是指向新分配的结点*/
p=s; /*p总是指向链表的最后一个结点*/
}
p->next=NULL; /*双链表的最后一个结点的后继指向NULL*/
return(h);
}
stud *search(stud *h,char *x) /*查找*/
{
stud *p; /*用于定位双链表中的结点*/
char *y;
p=h->next;
while(p)
{
y=p->name;
if(strcmp(y,x)==0)/*strcmp函数比较两个字符串的内容是否相等*/
return (p);/*若找到，返回当前结点*/
else
p=p->next;/*不相等就继续向下查找*/
}
printf("信息未找到/n");
}
void del(stud *p)/*删除*/
{
if(p->next!=NULL)/*确定要删除的结点是否为最后一个结点，最后一个结点后继为NULL*/
p->next->prior=p->prior;/*p结点后继的前驱赋予p结点的前驱*/
p->prior->next=p->next;/*p结点前驱的后继赋予p结点的后继*/
free(p); /*释放p结点的内存空间*/
}
void dip(stud *p) /*输出双链表*/
{
while(p)
{
printf("%s ",&*(p->name)); /*%s格式符要用字符数组的起始地址即第一个字符的地址，也可用(p->name)*/
p=p->next;
}
}
void main()
{
int number;
char sname[20];
stud *head,*sp; /*head用来标记双链表，sp用来定位结点*/
puts("请输入链表的长度：");
scanf("%d",&number);
head=creat(number);
sp=head->next; /*sp指向双链表的第一个结点(头结点为第0个结点)*/
printf("/n双链表内的数据为：/n");
dip(sp); /*输出链表*/
printf("/n请输入要查找的学生姓名：/n");
scanf("%s",sname);
sp=search(head,sname); /*查找链表中的结点*/
printf("/n你想要找的名子是：%s/n",&*(sp->name));
del(sp); /*删除sp结点*/
sp = head->next;
printf("/n现在的双链表是：/n");
dip(sp); /*输出链表*/
printf("/n");
}
3、创建循环链表
程序分析：循环链表与普通链表的操作基本一致，只是链表中最后一个结点的指针域指向头结点，使链表形成一个环，
从表中的任一结点出发均可找到表中的其它结点，在算法中循环遍历链表的判断条件不再是p->next是否为空，而是是否等于链表的头指针。
代码1如下：
#include<stdio.h>
#include<malloc.h>
typedef struct student
{
int num;
struct student *next;
}LNode,*LinkList;
/*定义链表的结构体类型*/
LinkList creat(void)
{
LinkList head;
LNode *p1,*p2;
/*p1用来指向新分配的结点，p2始终指向链表的最后一个结点，同时用p2->next=p1来链入新结点*/
char a;
head=NULL;/*新创建的链表的头指针为NULL(空)*/
a=getchar();
while(a!='/n')
{
p1=(LNode *)malloc(sizeof(LNode)); /*动态分配内存空间*/
p1->num=a;/*为结点的数据域赋值*/
if(head==NULL)/*指定链表的头指针*/
head=p1;
else
p2->next=p1; /*将新结点p1链入链表*/
p2=p1; /*p2指向刚链入的新结点，即让p2始终指向链表的最后一个结点*/
a=getchar();
}
p2->next=head;/*链表的最后一个结点的后继指向头结点*/
return head;
}
void main()
{
LinkList L1,head;
printf("/n请输入循环链表内容：/n");
L1 = creat();/*创建链表*/
head = L1;
printf("/n循环链接表：/n");
printf("%c",L1->num);
L1 = L1->next;
while(L1!=head)
{
/*判断条件为循环到头结点结束*/
printf("%c",L1->num);
L1=L1->next;
}
printf("/n/n");
}
代码2如下：
Llink CreatlinkLoop() //创建一个有环的链表{
Llink head=new Lnode;
//head->data=0;
head->next=NULL;
Lelemtype e;
Llink q=head;
int N=0;
cout<<"input elems:";
while(cin>>e)
{
Llink p=new Lnode;
++N;
p->data=e;
p->next=q->next;
q->next=p;
q=p;
}
cin.clear();
cin.sync();
srand(time(0));
q->next=Findnode(head,rand()%N); //随机产生环的接入点
return head;
}
{
if(n<=0)
return head;
Llink p=head->next;
for(int i=1;p&&i<n;++i)
p=p->next;
return p;
}
问题1：判断一个链表是否有环？
思路1：
此方法可找出环形链表的入口点，即n。
遍历每个节点并记录指针，然后和前面访问过的节点指针比较，看是否有重复的（指针重复即代表访问的节点有重复）。如果有重复的，说明到这个节点已经访问了一整个环，即可以得出这个链表是环形列表，算法停止；如果遍历整个链表，始终没有找到相同的节点指针，说明不是环形链表，算法停止。
简便起见，用线性表（具体可由数组实现）保存节点指针。算法的时间复杂度为O(n^2)。
代码示例：
struct NodeType
{
int data;
struct NodeType* next;
}
int isloop(NodeType* p)
{
struct NodeType* list[100];/*保存节点指针的线性表，注意声明时需要保证足够大到存下链表的所有节点，也就是下标上限不小于节点数。*/
int n = 0;/*记录 list 中保存的有效指针个数。*/
int i;
while(p != NULL) /*存在直接后继节点。*/
{
for(i = 0; i < n; ++i)
{
if(list[i] == p)/*存在重复节点。*/
return 1;/*返回 1 ，说明是环形列表。*/
}
list[n++] = p; /*记录节点。*/
p = p->next;/*准备遍历下一个指针。*/
}
return 0; /*遍历完整个链表，未发现重复节点，说明不是环形链表，返回 0 。*/
}
思路2：代码如下：设置两个指针(fast, slow)，初始值都指向头，slow每次前进一步，fast每次前进二步，如果链表存在环，则fast必定先进入环，而slow后进入环，两个指针必定相遇。(当然，fast先行头到尾部为NULL，则为无环链表) 程序如下：
bool IsExitsLoop(slist *head) { slist *slow = head, *fast = head; while ( fast && fast->next ) { slow = slow->next; fast = fast->next->next; if ( slow == fast ) break; } return !(fast == NULL || fast->next == NULL); }
找到环的入口点 假设单链表的总长度为L，头结点到环入口的距离为a，环入口到快慢指针相遇的结点距离为x，环的长度为r，慢指针总共走了s步，则快指针走了2s步。另外，快指针要追上慢指针的话，快指针至少要在环里面转了一圈多(假设转了n圈加x的距离，即nr+x)，而慢指针还没遍历完所有结点 （注释1：假设快、慢指针速度分别为2v、v，有一种临界情况，当快指针刚过连接点，慢指针就到达连接点，从快指针从连接点出发开始计时，快指针走两圈的时间是2r/2v=r/v，在r/v时间内慢指针只能走一圈，但快指针出发时，慢指针尚未到达连接点，故慢指针在相遇时未走完一圈），得到以下关系： s = a + x; （注释1已验证） 2s = a + nr + x; =>a + x = nr; =>a = nr - x; 由上式可知：若在头结点和相遇结点分别设一指针，同步(单步)前进，则最后一定相遇在环入口结点，搞掂！ 附图：
slist* FindLoopPort(slist *head)
{
slist *slow = head, *fast = head;
while ( fast && fast->next )
{
slow = slow->next;
fast = fast->next->next;
if ( slow == fast ) break;
}
if (fast == NULL || fast->next == NULL)
return NULL;
slow = head;
while (slow != fast)
{
slow = slow->next;
fast = fast->next;
}
return slow;
}
亦可以用类似与hash表的方法，即设立一个数组，将链表结点中的值做数组下标，当赋值冲突时就是环的接入点
{
if(!p||!p->next)
return true;
int a[MAXSIZE],n=0;
memset(a,0,sizeof(int)*MAXSIZE);
p=p->next;
while(p)
{
if(a[p->data]==-1)//存在环时，会发生冲突
{
cout<<"\nLoop node: "<<p->data<<endl<<"\nLen of node: "<<n<<endl;
return true;
}
a[p->data]=-1;
++n;
p=p->next;
}
return false;
}
如何知道环的长度？
记录下问题1的碰撞点p，slow、fast从该点开始，再次碰撞所走过的操作数就是环的长度s。
证明如下：
链表形状类似数字 6 。
假设甩尾（在环外）长度为 a（结点个数），环内长度为 b 。
则总长度（也是总结点数）为 a+b 。
从头开始，0 base 编号。
将第 i 步访问的结点用 S(i) 表示。i = 0, 1 ...
当 i＜a 时，S(i)=i ；
当 i≥a 时，S(i)=a+(i-a)%b 。
分析追赶过程:
两个指针分别前进，假定经过 x 步后，碰撞。则有：S(x)=S(2x)
由环的周期性有：2x=tb+x 。得到 x=tb 。
另，碰撞时，必须在环内，不可能在甩尾段，有 x>=a 。
连接点为从起点走 a 步，即 S(a)。
S(a) = S(tb+a) = S(x+a)。
得到结论：从碰撞点 x 前进 a 步即为连接点。
根据假设易知 S(a-1) 在甩尾段，S(a) 在环上，而 S(x+a) 必然在环上。所以可以发生碰撞。
而，同为前进 a 步，同为连接点，所以必然发生碰撞。
综上，从 x 点和从起点同步前进，第一个碰撞点就是连接点。
void Isloop(Llink head)
{
if(!head||!head->next)
return;
Llink p,q;
bool loop=false;
p=q=head->next;
while(q&&q->next)//判断是否有环
{
p=p->next;
q=q->next->next;
if(p==q)
{
loop=true;
break;
}
}
if(!loop)
cout<<"This link has not loop\n";
else
{
cout<<"This link has a loop\n";
Llink r=p;
q=head->next;
int nonloop=1,loopcount=1;
//nonloop计算非环结点数，loopcount计算环上结点数
do//计算环上的结点数
{
p=p->next;
++loopcount;
}while(p!=r);
--loopcount;
while(p!=q)//得到环的入口结点，同时计算得到非环的结点数
{
p=p->next;
q=q->next;
++nonloop;
}
--nonloop;
cout<<"\nStart of loop: "<<p->data<<endl; //环的入口点
cout<<"\nCount of nonloop: "<<nonloop //非环的结点数
<<"\nCount of loop: "<<loopcount //环的结点数
<<"\nCount of Linknode: "<<nonloop+loopcount<<endl; /链表的总节点数
}
}
判断两个单链表是否相交，如果相交，给出相交的第一个点（两个链表都不存在环）。
比较好的方法有两个：
一、将其中一个链表首尾相连，检测另外一个链表是否存在环，如果存在，则两个链表相交，而检测出来的依赖环入口即为相交的第一个点。
二、如果两个链表相交，那个两个链表从相交点到链表结束都是相同的节点，我们可以先遍历一个链表，直到尾部，再遍历另外一个链表，如果也可以走到同样的结尾点，则两个链表相交。
这时我们记下两个链表length，再遍历一次，长链表节点先出发前进(lengthMax-lengthMin)步，之后两个链表同时前进，每次一步，相遇的第一点即为两个链表相交的第一个点。
扫一扫
2677
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
