线性表之循环链表的建立、查找、插入和删除(附C++程序)



一、循环链表的基本概念

定义:循环链表是另一种形式的链式存储结构。循环链表的任意元素都有一个前驱和一个后继,所有数据元素在关系上构成逻辑上的环。他的特点是表中尾结点的指针域不再是空,而是指向表头的节点,整个链表形成一个环。由此,从表中的任一点出发,均可找到链表中的其他的节点。循环链表又分为循环单链表和循环双链表。

二、循环单链表的算法

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 i1个节点,继*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
		}			
	}
}

[上一篇]:数据结构之双向链表的建立、查找、插入和删除(附C++程序)

  • 4
    点赞
  • 43
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值