一、循环链表的基本概念
定义：循环链表是另一种形式的链式存储结构。循环链表的任意元素都有一个前驱和一个后继，所有数据元素在关系上构成逻辑上的环。他的特点是表中尾结点的指针域不再是空，而是指向表头的节点，整个链表形成一个环。由此，从表中的任一点出发，均可找到链表中的其他的节点。循环链表又分为循环单链表和循环双链表。
二、循环单链表的算法
2.1 循环单链表的算法
循环链表是一个首尾相接的链表，将单链表的最后一个指针域改由NULL改为指向表头结点这就是单链式的循环链表，并称为循环单链表。
1.建立循环链表
（1）采用头插法建立循环单链表
该方法从一个空链表开始，读取数组a中的元素，生成新的节点，将读取的数据存储到新节点的数据域中，然后将新节点插入到当前的链表的表头上，直到结束为止。
//头插法创建循环单链表
void CreateList_L(LinkList &L, ElemType a[], int n)
{
LinkList *s;
int i;
L=(LinkList*)malloc(sizeof(LinkList)); //创建头节点
L->next=L; //置为空的循环链表
for(int i=0;i<n;i++)
{
s = (LinkList*)malloc(sizeof(LinkList)); //创建新节点
s->data = a[i];
s->next = L->next; //s指向下一个
L->next = s; //再将s给单链表L的表头
}
}
（2）采用尾插法建立循环单链表
该方法是将新节点插到当前链表的表尾上，为此必须增加一个尾节点指针r，使其始终指向当前链表的尾节点，最后让r的next指向头节点。
//尾插法创建单链表
void CreateList_R(LinkList *&L,ElemType a[], int n)
{
LinkList *s,*r;
int i;
L=(LinkList*)malloc(sizeof(LinkList)); //创建头节点
r=l;;
for(int i=0;i<n;i++)
{
s=(LinkList*)malloc(sizeof(LinkList));
s->data = a[i];
r->next = s;
r = s;
}
r->next = NULL;
}
2.在循环单链表中查找元素值为x的节点
用p指针遍历循环单链表L，若当前节点的*p的data值为e，则返回其序号。否则返回0。
//按值查找
int FindLinkList(LinkList *L, ElemType e)
{
int j=1;
LinkList *p = L->next;
while(p!=L && p->data != e)
{
p = p->next;
j++;
}
if(p == L)
return 0;
else
return j;
}
3.在循环单链表中插入节点操作
插入运算是将值为x的新节点插入到循环单链表的第i个位置上，也就是在第i个节点的之前插入一个新的节点。先在单链表中找到第i-1个节点，再在其后插入新的节点。
//在循环单链表的第i个元素之前插入元素x
void InsElem(LinkList *L, ElemType x, int i)
{
int j=0;
LinkList *p = L, *s;
if(i<=0) return 0;
while(p!=L && j<i-1) //查找第i-1个结点*p
{
j++;
p = p->next;
}
if(p == L) return 0; //未找到结点返回0
else
{
s = (LinkList *)malloc(sizeof(LinkList)); //创建新结点
s->data = x; //存放元素x
s->next = p->next; //s指向i的元素位置，即p->next的指向
p->next = s; //插入s后，那么p指向s
return 0; //成功返回0
}
}
4.在循环单链表中删除节点操作
先在循环单链表中找到第 i − 1 i-1 i−1个节点，继*p节点，再删去其后的节点q。
int DelElem(LinkList *&L, int i)
{
int j=0;
LinkList *p = L, *q; //q是要被删除的元素
if(i<=0) return 0;
while(p != L && j<i-1)
{ //查找第i-1个结点*p
j++;
p = p->next;
}
if(p == L) return 0; //未找到结点返回0
else{
q = p->next;
if(q == L) return 0;
else{
p->next = q->next; //i-1指针指向i的指针
free(q); //释放q
return 1; //成功返回1
}
}
}
2.2 循环双链表的算法
1.建立循环双链表
（1）采用头插法建立循环双链表
该方法从一个空链表开始，读取数组a中的元素，生成新的节点，将读取的数据存储到新节点的数据域中，然后将新节点插入到当前的链表的表头上，直到结束为止。算法如下：
void CreateDListF(DLinkList *&L, ElemType a[], int n)
{
DLinkList *s;
int i;
L=(DLinkList *)malloc(sizeof(DLinkList )); //创建头节点
L->next=L->prior=L;
for(int i=0;i<n;i++)
{
s = (DLinkedlist *)malloc(sizeof(DLinkedlist ));
s->data = a[i];
s->next = L->next; //s指向下一个
if ( L->next!=NULL)
{
L->next->prior=s;
}
L->next = s; //再将s给单链表L的表头
s->prior=L;
}
}
（2）采用头插法建立循环双链表
该方法是将新节点插到当前链表的表位上，为止必须增加一个尾节点指针r，使其始终指向当前链表的尾节点，最后让r的next的指向头节点，头节点的p指向r节点，从而构成循环双链表。
循环双链表的尾插法：
void CreateDListR(DLinkList *&L, ElemType a[], int n)
{
DLinkedlist *s, *r;
int i;
L=(DLinkList *)malloc(sizeof(DLinkList )); //创建头节点
r = L;
for(i = 1; i< = n; i++)
{
s =(DLinkList *)malloc(sizeof(DLinkList ));
s->data = a[i];
r->next = s;
s->prior = r;
r = s;
}
r->next = L;
L->prior=r;
}
2.在循环双链表中查找元素值为x的节点
用p指针遍历循环链表L,若当前节点的*p的data值为x，则返回其序号。若未找到，则返回0.
int Finfnode(DLinkList *L, ElemType x)
{
DLinkList *p = L->next;
int i=1;
while(p != L && p->data != x)
{
i++;
p = p->next;
}
if (p==L) return 0; //未找到时返回0；
else return i; //找到时，返回序号
}
3.插入节点操作
假设在双链表中p所指的结点之后插入一个结点s，其操作语句描述为：
//在单链表的第i个元素之前插入元素x
int InsElem(DLinkedlist *&L, ElemType x, int i)
{
int j=0;
DLinkedlist *p = L, *s;
while(p != L && j<i-1) //查找第i-1个结点*p
{
j++;
p = p->next;
}
if(p == L) return 0; //未找到结点返回0
else
{
s = (DLinkedlist *)malloc(sizeof(DLinkedlist )); //创建新结点
s->data = x; //存放元素x
s->next = p->next; //s指向i的元素位置，即p->next的指向
if (p->next != L) p->next->prior=s;
s->prior=p;
p->next = s; //插入s后，那么p指向s
return 1; //成功返回1
}
}
4.插入节点操作
设要删除双链表中p结点的后继结点，其操作的语句为：
算法如下：
int DelElem((DLinkedlist *&L, ElemType x, int i)
{
int j=0;
DLinkedlist *p = L, *q; //q是要被删除的元素
if(i<=0) return 0;
while(p!=L && j<i-1)
{ //查找第i-1个结点*p
j++;
p = p->next;
}
if(p == L) return 0; //未找到结点返回0
else{
q = p->next;
if(q == L) return 0;
p->next = q->next; //i-1指针指向i的指针
if (p->next != L) p->next->prior=p
free(q); //释放q
return 1; //成功返回1
}
}
}
1047
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
