循环单链表的基本操作

最新推荐文章于 2023-01-23 20:26:12 发布
最新推荐文章于 2023-01-23 20:26:12 发布
阅读量3.4k 收藏 32
点赞数 11
分类专栏： 头歌实践教学平台 C 文章标签： 数据结构 头歌实践教学平台 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45917176/article/details/125536295
版权

第1关：循环单链表的插入操作

任务描述

本关任务：编写循环单链表的插入操作函数。

测试说明

平台会对你编写的代码进行测试：

测试输入：
5
12 47 5 8 69
1
99
预期输出：
插入成功，插入后单链表如下：
99 12 47 5 8 69

测试输入：
5
12 47 5 8 69
7
99
预期输出：
插入位置不合法，插入失败！

输入说明
第一行输入单链表的数据元素的个数M；
第二行输入单链表M个整数；
第三行输入要插入元素的位置；
第四行输入要插入的数据元素的值。

输出说明
第一行输出插入是否成功的提示信息；
如果插入成功，第二行输出插入元素后的单链表所有元素；如果插入失败，则不输出第二行。

代码如下

#include <stdlib.h>
#include <stdio.h>
#include <iostream>
using namespace std;

/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);
/* 循环单链表类型定义 */
typedef struct LNnode
{	
	ElemType data;
	struct LNnode *next;
}LNnode,*LinkList;

void InitList(LinkList &L);
int ListInsert(LinkList L,int i,ElemType e) ;
void ListTraverse(LinkList L,void(*vi)(ElemType));
int ListLength(LinkList L);

int main()               //main() function 
{	
     LinkList A;
     ElemType e;
     InitList(A);
      int n,i;
     // cout<<"Please input the list number ";
     cin>>n;
     for(i=1;i<=n;i++)
        { 
		   cin>>e;
         ListInsert(A, i, e);
       }
	//cout<<"请输入插入的位置："<<endl;
	cin>>i;
	//cout<<"请输入插入的值："<<endl;
	input(e);
	if(  ListInsert(A,i,e) )
    {
      cout<<"插入成功，插入后循环单链表如下："<<endl;
      ListTraverse(A,output) ;
    }
    else
    	cout<<"插入位置不合法，插入失败！"<<endl;
    return  0;  
 }


/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
cin>>s;
}
void output(ElemType s)
 {
cout<<s<<" ";
}
int equals(ElemType a,ElemType b)
{
	if(a==b)
		return  1;
	else
		return  0;
}

/*****循环单链表的基本操作*****/
void InitList(LinkList &L)
{ 
	// 构造一个空的循环单链表L
	L=(LinkList)malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
	if(!L) // 存储分配失败
		return ;
	L->next=L; // 指针域为L	
}

// 求循环链表长度
int ListLength(LinkList L){
	LinkList q=L->next;
	int i=0;
	while(q!=L){
		i++;
		q=q->next;
	}
	return i;
}
int ListInsert(LinkList L,int i,ElemType e) 
{
	// 在带头结点的循环单链表L的第i个元素之前插入元素e  
	/********** Begin **********/ 
	int j=0;
	LinkList p=L,s;
	if(i<1 || i>ListLength(L)+1)
		return 0;
	while(j<i-1){
		p=p->next;
		j++;
	}
	s=(LinkList)malloc(sizeof(LNnode));
	s->data=e;
	s->next=p->next;
	p->next=s;
	return 1;
	/********** End **********/
}

void ListTraverse(LinkList L,void(*vi)(ElemType))
{ 
	//依次对循环单链表L的每个数据元素调用函数vi()
	LNnode *p=L->next;
   while (p!=L)
   {	
		vi(p->data);
		p=p->next;
   }
   printf("\n");	
}

第2关：循环单链表的删除操作

任务描述

本关任务：编写循环单链表的删除操作函数。

测试说明

平台会对你编写的代码进行测试：

测试输入：
5
12 47 5 8 69
1
预期输出：
删除成功，删除后单链表如下：
47 5 8 69
删除元素的值：12

测试输入：
5
12 47 5 8 69
6
预期输出：
删除位置不合法，删除失败！

输入说明
第一行输入循环单链表的长度M；
第二行输入循环单链表的M个整数；
第三行输入要删除元素的位置；

输出说明
第一行输出删除是否成功的提示信息；
如果删除成功，第二行输出删除元素后的循环单链表；第三行输出删除的数据元素；如果删除位置不合法，不输出第二行和第三行。

代码如下

#include <stdlib.h>
#include <stdio.h>
#include <iostream>
using namespace std;

/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);

/* 循环单链表类型定义 */
typedef struct LNnode
{	
	ElemType data;
	struct LNnode *next;
}LNnode,*LinkList;

void InitList(LinkList &L);
int ListInsert(LinkList &L,int i,ElemType e) ;
int ListDelete(LinkList L,int i,ElemType &e);
void ListTraverse(LinkList L,void(*vi)(ElemType));
int ListLength(LinkList L);

int main()               //main() function 
{	
	LinkList A;
	ElemType e;
	InitList(A);
	int n,i;
	// cout<<"Please input the list number ";
	cin>>n;
	for(i=1;i<=n;i++)
	{ 
		cin>>e;
		ListInsert(A, i, e);
	}
	//cout<<"请输入删除的位置："<<endl;
	cin>>i;	
	if(  ListDelete(A,i,e) )
	{
		cout<<"删除成功，删除后循环单链表如下："<<endl;
		ListTraverse(A,output) ;
		cout<<"删除元素的值：";
	   output(e);
   	   cout<<endl;
	}
	else
		cout<<"删除位置不合法，删除失败！"<<endl;
}



/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
	cin>>s;
}
void output(ElemType s)
{
	cout<<s<<" ";
}
int equals(ElemType a,ElemType b)
{
	if(a==b)
		return  1;
	else
		return  0;
}

/*****循环单链表的基本操作*****/
void InitList(LinkList &L)
{ 
	// 构造一个空的循环单链表L
	L=(LinkList)malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
	if(!L) // 存储分配失败
		return ;
	L->next=L; // 指针域为L	
}
int ListInsert(LinkList &L,int i,ElemType e) 
{
	// 在带头结点的循环单链表L的第i个元素之前插入元素e  
	int j=1;
   LNnode *pre=L,*p=pre->next,*s;
   if (i<=0) return 0;	//参数i错误返回0
   while (p!=L && j<i)	//查找第i个结点p和其前驱结点pre
   {	
	j++;
	pre=p;
	p=p->next;	//pre、p同步后移一个结点
   }
   if (p==L && i>=j+1) return 0;//参数i>n+1时错误返回0
   else				//成功查找到第i个结点的前驱结点pre
   {	
	s=(LNnode *)malloc(sizeof(LNnode));
	s->data=e;		//创建新结点用于存放元素x
	s->next=pre->next;	//将s结点插入到pre结点之后
	pre->next=s;
	return 1;		//插入运算成功,返回1
   }
}

void ListTraverse(LinkList L,void(*vi)(ElemType))
{ 
	//依次对循环单链表L的每个数据元素调用函数vi()
	LNnode *p=L->next;
   while (p!=L)
   {	
		vi(p->data);
		p=p->next;
   }
   printf("\n");	
}

// 计算循环链表的长度
int ListLength(LinkList L){
	int i=0;
	LinkList q=L->next;
	while(q!=L){
		q=q->next;
		i++;
	}
	return i;
}


int  ListDelete(LinkList L,int i,ElemType &e) // 不改变L
{ 
	// 在带头结点的循环单链表L中，删除第i个元素，并由e返回其值
	/********** Begin **********/ 
	int j=0;
	LinkList p=L,r;
	if(i<1 || i>ListLength(L))
		return 0;
	while(j<i-1){
		p=p->next;
		j++;
	}
	r=p->next;
	p->next=r->next;
	e=r->data;
	free(r);
	return 1;
	/********** End **********/
}

第3关：将两个循环单链表合并成一个循环单链表

任务描述

本关任务：设有两个带头结点的循环单链表LA=（a1，a2，…，an），LB=（b1，b2，…，bm），编写一个算法，将LA、LB这两个循环单链表合并为一个循环单链表LA=（a1，…，an，b1，…bm），其头指针为LA。

测试说明

平台会对你编写的代码进行测试：

测试输入：
10
12 47 5 8 6 92 45 63 75 38
8
24 75 86 9 45 63 12 34

预期输出：
12 47 5 8 6 92 45 63 75 38 24 75 86 9 45 63 12 34

输入说明
第一行输入循环单链表LA的长度M；
第二行输入循环单链表LA的M个整数；
第三行输入循环单链表LB的长度N；
第四行输入循环单链表LB的N个整数；

输出说明
输出合并后的循环单链表的所有元素。

代码如下

#include <stdlib.h>
#include <stdio.h>
#include <iostream>
using namespace std;

/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);
/* 循环单链表类型定义 */
typedef struct LNnode
{	
	ElemType data;
	struct LNnode *next;
}LNnode,*LinkList;

void InitList(LinkList &L);
int ListInsert(LinkList &L,int i,int e) ;
void ListTraverse(LinkList L,void(*vi)(ElemType));
LinkList   merge_1(LinkList LA,LinkList LB);
int main()               //main() function 
{	
  LinkList A,B;
  ElemType e;
  InitList(A);
  InitList(B);
  int n,m,i;
  cin>>n;
  for(i=1;i<=n;i++)
  { 
    cin>>e;
    ListInsert(A, i, e);
  }
  cin>>m;
  for(i=1;i<=m;i++)
  { 
    cin>>e;
    ListInsert(B, i, e);
  }
  A=merge_1(A,B);
  ListTraverse(A,output) ;   
  return  0;  
 }


/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
	cin>>s;
}
void output(ElemType s)
{
	cout<<s<<" ";
}
int equals(ElemType a,ElemType b)
{
	if(a==b)
		return  1;
	else
		return  0;
}

/*****循环单链表的基本操作*****/
void InitList(LinkList &L)
{ 
	// 构造一个空的循环单链表L
	L=(LinkList)malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
	if(!L) // 存储分配失败
		return ;
	L->next=L; // 指针域为L	
}
int ListInsert(LinkList &L,int i,ElemType e) 
{
	// 在带头结点的循环单链表L的第i个元素之前插入元素e  
	int j=1;
   LNnode *pre=L,*p=pre->next,*s;
   if (i<=0) return 0;	//参数i错误返回0
   while (p!=L && j<i)	//查找第i个结点p和其前驱结点pre
   {	
	j++;
	pre=p;
	p=p->next;	//pre、p同步后移一个结点
   }
   if (p==L && i>=j+1) return 0;//参数i>n+1时错误返回0
   else				//成功查找到第i个结点的前驱结点pre
   {	
	s=(LNnode *)malloc(sizeof(LNnode));
	s->data=e;		//创建新结点用于存放元素x
	s->next=pre->next;	//将s结点插入到pre结点之后
	pre->next=s;
	return 1;		//插入运算成功,返回1
   }
}

void ListTraverse(LinkList L,void(*vi)(ElemType))
{ 
	//依次对循环单链表L的每个数据元素调用函数vi()
	LNnode *p=L->next;
   while (p!=L)
   {	
		vi(p->data);
		p=p->next;
   }
   printf("\n");	
}

LinkList   merge_1(LinkList LA,LinkList LB)
{  
  //将两个采用头指针的循环单链表的首尾连接起来
  /********** Begin **********/ 
  LNnode *p,*q;
  p=LA;q=LB;
  while(p->next != LA) p=p->next;
  while(q->next != LB) q=q->next;
  q->next=LA;
  p->next=LB->next;
  free(LB);
  return LA;
  /********** End **********/
}
杼蛘
关注
  • 11
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
【头歌】循环单链表的基本操作
qq_39977056的博客
01-25 3571
an），LB=（b1，b2，…算法思想： 先找到两个链表的尾，并分别由指针p、q指向它们，然后将第一个链表的尾结点与第二个表的第一个结点链接起来，并修改第二个表的尾结点，使它的链域指向第一个表的头结点。将尾结点的next域用一个特殊值NULL（空指针，不指向任何结点，只起标志作用）表示，这样的单链表为非循环单链表，通常所说的单链表都是指这种类型的单链表。=L作为循环条件，当p==L时循环结束，此时p回过来指向头结点，所以p应该初始化指向第一个数据结点而不是头结点，否则循环内的语句不会执行。
C语言数据结构：带头结点的的单链表的插入，删除，查找
weixin_45941004的博客
03-24 2388
C语言数据结构：带头结点的的单链表的插入，删除，查找 C语言数据结构：带头结点的的单链表的插入，删除，查找 首先是创建一个空的线性表 先上链表部分的定义 typedef struct LNode *PtrToLNode; struct LNode { ElementType Data; PtrToLNode Next; }; typedef PtrToLNode Position; typedef PtrToLNode List; typedef的作用是可以自定义类型的名字，例如 type
【头歌答案】一百个实训答案总集
热门推荐
weixin_44505587的博客
10-16 1万+
【头歌答案】 答案查询的入口网页版- 小程序版：![在这里插入图片描述](https://img-blog.csdnimg.cn/20200727161538813.jpg?- 其他各类实训答案的[**目录**见这里](https://blog.csdn.net/weixin_44505587/article/details/107909026)- 答案获取的方法简介见[这里](https://blog.csdn.net/weixin_44505587/article/details/107825779)
第1关：有序单链表的插入操作【头歌】
shaojiuli的博客
05-01 2472
int ListSortInsert (LinkList &L, ElemType e,int (*compare)(ElemType,ElemType)) { /********** Begin **********/ LNnode* s = (LNnode*)malloc(sizeof(LNnode)),*p,*q; if (s == NULL) return 0; s->data = e; s->next = NULL; p = L; q = L->nex.
【数据结构|链表】单链表基本操作
爱喝冰红茶的方舟的博客
10-24 1043
链表基本操作实现
C/C++合并两个升序链表
小源同学的博客
03-21 4813
算法的思想 1.需要合并的两个链表La,Lb，合并之后的链表Lc(用La的头节点)。 2.定义两个辅助指针Pa,Pb分别是链表La,Lb的复制指针。 3.从首元节点开始比较，当两个链表都没有到达链表尾部的时候，依次取其中较小的数据进行链接到Lc的最后 4.如果两个元素的值相同，取La链的，把Lb链表的元素删除(确保新链表没有重复的元素) 5.当一个链表结束的时候，把非空链表剩余的所有元素链接在Lc表的最后 6.释放Lb的头节点(Lb链表就被删除了) 代码实现＋注释 void MergeList(LinkLi
非循环单链表的操作
01-03
实验结论表明，这样的实践练习有助于巩固理论知识，加深对单链表操作的理解，包括创建、复制、查询、插入和删除等基本操作。通过此类实验，学生能够更好地应对在实际编程中遇到的有前后相继特征的数据结构问题。对于...
关于入门单链表的基本操作
04-01
理解并熟练掌握这些基本操作对于理解和应用更复杂的数据结构，如双向链表、循环链表、链表栈和链表队列至关重要。同时，它们也是解决算法问题的基础，比如在面试中常见的链表相关问题。因此，对于任何想要进入IT行业...
单链表基本操作.rar
04-01
这个压缩包文件“单链表基本操作.rar”包含了一个名为“单链表基本操作.docx”的文档，我们可以从中学习到关于单链表的各种核心概念和操作。 单链表是由一系列节点构成的线性数据结构，每个节点包含两部分：数据域...
java单链表的基本操作.zip
01-09
本资料主要涵盖了Java单链表的基本操作，包括链表的定义、创建、插入、删除、遍历等核心概念。 单链表由一系列节点组成，每个节点包含两部分：数据元素（data）和指向下一个节点的引用（next）。链表的头部是第一个...
基于Java实现的单链表基本操作之链表反转.zip
最新发布
04-26
在这个基于Java实现的单链表基本操作中，我们将重点关注链表反转这一特定操作。 链表反转是编程面试中常见的问题，它要求我们改变链表中节点的顺序，使得原链表的最后一个节点成为新链表的第一个节点，原链表的第一...
【线性表】链表的并归(完整代码)
weixin_54667422的博客
03-26 2015
链表的并归操作(完整版)
【头歌】单链表的基本操作
qq_39977056的博客
01-23 1万+
由于单链表中每个结点的存储地址是存放在其前趋结点的指针域中的，而第一个结点无前趋，头指针L指向第一个结点，对于整个单链表的读取必须从头指针开始，同时，由于单链表中最后一个结点的指针域为“空”（NULL），没有直接后继元素，对于整个单链表的读取必须在尾结点结束。要在带头结点的单链表L中删除第i个结点，则同样要先找到第i-1个结点，使p指向第i-1个结点，使q指向第i个结点，然后令第i-1个结点的指针域指向第i+1个结点，而后删除q指向的第i个结点并释放结点空间。= NULL时，才能进行删除结点的操作。
盘点那些必问的数据结构算法题之链表
Java面试精选的博客
07-03 354
0 概述 链表作为一种基础的数据结构，在很多地方会用到。如在Linux内核代码，redis源码，python源码中都有使用。除了单向链表，还有双向链表，本文主要关注单向链表(含部分循环链表题目，会在题目中注明，其他情况都是讨论简单的单向链表)。双向链表在redis中有很好的实现，也在我的仓库中拷贝了一份用于测试用，本文的相关代码在 这里。 https://github.com/shishujuan/data-structure-algorithms 1 定义 先定义一个单向链表结构，如下，定义了链表
力扣练习——5 分隔链表
qq_43403657的博客
07-03 180
分隔链表
二叉树的二叉链表存储及基本操作
qq_45917176的博客
07-04 1万+
数据结构--二叉树的二叉链表存储及基本操作
循环单链表基本操作c
11-20
循环单链表的基本操作包括：创建、插入、删除、查找、遍历等。下面是循环单链表的基本操作C语言实现的示例代码： 1. 创建循环单链表 ```c typedef struct Node { int data; struct Node *next; } Node; Node *...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杼蛘

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值