首页 / 更多教程 / 小甲鱼笔记：数据结构——线性表（四）循环链表和双向链表，约瑟夫问题，魔术师发牌问题，判断一个单链表是否有环

小甲鱼笔记：数据结构——线性表（四）循环链表和双向链表，约瑟夫问题，魔术师发牌问题，判断一个单链表是否有环

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了小甲鱼笔记：数据结构——线性表（四）循环链表和双向链表，约瑟夫问题，魔术师发牌问题，判断一个单链表是否有环，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8918字，纯文字阅读大概需要13分钟。

内容图文

小甲鱼笔记：数据结构——线性表（四）循环链表和双向链表，约瑟夫问题，魔术师发牌问题，判断一个单链表是否有环

一、循环链表

1. 背景

单链表只能从头指向尾部，如果不从头结点出发，就无法访问到全部结点
将单链表中终端结点的指针端由空指针改为指向头结点，使整个单链表形成一个环
头尾相连的单链表就是单循环链表，简称循环链表
循环链表的单链表主要差异在于循环的判断空链表的条件上
- if(head->next == head)
- 将终端结点用指针rear指示，找到终端结点的时间复杂度为O(1);
- 因为终端用rear表示，则开始结点应该为rear->next->next。时间复杂度也是O(1);

2.初始化循环链表

void ds_init(node **pNode)//**表示链表上的一个元素 如果
{
	int item;
	node *temp;
	node *target;

	printf("输入结点的值，输入0完成初始化\n");
	while(1){
		scanf("%d",&item);
		fflush(stdin);
		if(item == 0)
			return;
		
		if((*pNode) ==NULL){
		/*循环链表中只有一个结点*/
		*pNode =(node*)malloc(sizeof(struct CLinkList));
		if(!(*pNode)){
			exit(0);
			(*pNode)->data = item;
			(*pNode)->next =*pNode;
			}
		else{
			/*找到next指向第一个结点的结点*/
			for(target =(*pNode);target->next !=(*pNode);target =target->next)
				;
			/*生成一个新结点*/
			temp = (node *)malloc(sizeof(struct CLinkList));

			if(!temp)
				exit(0);
			temp->data = item;
			temp->next = *pNode;
			target->next =temp;
		}
	} 
}

3. 循环链表的插入

/*链表存储结构的定义*/
typedef struct CLinkList{
	int data;
	struct CLinkList *next;
}node;

/*插入结点*/
/*参数：链表的第一个结点，插入的位置*/
void ds_insert(node **pNode,int i){
	node *temp;
	node *target;
	node *p;
	int item;
	int j = 1;
	printf("请输入要插入结点的值：");
	scanf(”%d“,&item);
	
	if(i =1){
		//新插入的节点作为第一个节点
		temp =(node *)malloc(struct CLinkList);

		if(!temp)
			exit(0);
		
		temp->data =item;
	/*寻找最后一个节点*/
	for(target =(*pNode);target->next!=(*pNode);target =target->next)	
			;
		temp->next =(pNode);
		target->next =temp;
		*pNode =temp;
	}
	else{
		target =*pNode;
		for(;j < (i-1);++j){
			target=target->next;
		}
		//target指向第三个元素
		temp = (node *)malloc(sizeof(struct CLinkList));
		if(!temp)
			exit(0);
		temp->data =item;
		p = target->next;
		target->next = temp;
		temp->next = p;
	}
}

4. 循环链表的删除

void ds_delete(node **pNode,int i){
	node *target;
	node *temp;
	int j = 1;
	if(i == 1){
	//删除的第一个结点
	/*找到最后一个结点*/
	for(target = *pNode;target->next !=*pNode;target = target->next)
		;
		temp =*pNode;
		*pNode =(*pNode)->next;
		target->next =*pNode;
		free(temp);
	}
	else{
		target= *pNode;
		for(;j<i-1;++j){
			target=target->next;
		}
		temp = target->next;
		target->next = temp->next;
		free(temp);
	}
}

5. 返回结点所在的位置

int ds_search(node *pNode,int elem){
	node *target;
	int i = 1;
	for(target = pNode;target->data !=elem && target->next !=pNode;++i){
		target = target->next;
	}
	if(target->next == pNode)/*表中不存在改元素*/
		return 0；
	else
		return 1;
}

二、约瑟夫问题

1.问题提出

一共有41个人围城一个圈，由第一个人开始报数，每报到第3个人的时候，该人就必须自杀，然后由下一个人报数。直到所有人都自杀为止。

2. 代码实现

#include <stdio.h>
#include <stdlib.h>
typeof struct node{
	int data;
	struct node *next;
}node;
node *create(int n){
	node *p =NULL,*head;
	head = (node *)malloc(sizeof (node ));
	p = head;
	node *s;
	int i = 1;
	
	if( 0 !=n ){
		while( i <= n){
			s = (node *)malloc(sizeof(node));
			s->data = i++;
			p->next = s;
			p = s;
		}
		s->next = head->next;
	}
	free(head);
	
	return s->next;
}

int main(){
	int n = 41;
	int m = 3;
	int i;
	node *p = create(n);
	node *temp;
	m %=n;
	
	while( p !=p->next){
		for(i = 1;i <= m-1;i++){
			p = p->next; 
		}
		printf("%d->",p->next->data);
		
		temp = p->next;		//删除第m个节点
		p->next = temp->next;
		free(temp);
		
		p = p->next;
	}
	printf("%d\n"，p->data);
	return 0;
}

三、循环链表的特点

在单链表中，我们有了头结点，可以用O(1)的时间访问第一个结点，但对于要访问最后一个结点，我们必须要挨个往下索引，所以需要O(n)的时间
我们可以用O(1)的时间可以由链表指针访问到最后一个结点
我们用指向终端结点的尾指针来表示循环链表

小甲鱼笔记：数据结构——线性表（四）循环链表和双向链表，约瑟夫问题，魔术师发牌问题，判断一个单链表是否有环 - 文章图片

1、例题：实现将两个线性表（a1,a2,…,an）和（b1,b2,…,bm）连接成一个线性表（）a1,…,an,b1,…,bm)的运算

分析
- 在单链表或头指针表示的单链表以上做这种链接操作，都需要遍历第一个链表，找到结点an，然后将结点b1链到到an的后面，其执行时间是O(n)
- 若在尾指针表示的单循环链表上实现，则只需要修改指针，无需遍历，其执行时间是O(1)
如图所示

2、代码实现

//假设A,B为非空循环链表的尾指针
LinkList Connect(LinkList A,LinktList B){
	LinkList p = A-<next; //保存A表的头结点位置
	
	A->next = B->next->next;//B表的开始结点连接到A表尾

	free(B->next);//释放B表的头结点

	B->next = p;

	return B;//返回新循环链表的尾指针
}

四、判断单链表是否有环

方法一：
- 使用p,q两个指针，p总是向前走，但q每次都从头开始走，对于每个节点，看p走的步数是否和q一样。
- 如果，当p从6走到3时，用了6步，此时若q从head出发，则只需要两步到3，因而步数不等，出现矛盾，存在环
方法二：
- 使用p，q两个指针，p每次向前走一步，q每次向前走两步，若在某个时候p==q。则存在环。

#include "stdio.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;/*Status是函数的类型，其值是函数结果状态代码*/
typedef int ElemType;/*ElemType类型根据实际情况而定，这里假设为int*/

typedef struct Node{
	ElemType data;
	struct Node *next;
}Node,* LinkList;

/*初始化带头结点的空链表*/
Status InitList(LinkList *L){
	*L = (LinkList)malloc(sizeof(Node));/*产生头结点，并使L指向此头结点*/
	if(!(*L))/*存储分配失败*/
		return ERROR;
	(*L)->next = NULL;/*此指针域为空*/
	
	return OK;
}

/*初始条件：顺序线性表L已存在，操作结果：返回L中数据元素个数*/
int ListLength(LinkList L){
	int i = 0;
	LinkList p = L->next;//p指向第一个结点
	while(p){
		i++;
		p=p->next;
	}
	return i;
}
/*随机产生n个元素的值，建立带表头结点的单链线性表L（头插法）*/
void CreateListHead(LinkList *L,int n){
	ListList p;
	int i;
	srand(time);	//初始化随机数种子
	*L = (LinkList)malloc(sizeof(Node));
	(*L)->next =NULL;		//建立一个带头结点的单链表
	for(i = 0;i < n;i++){
		p = (LinkList)malloc(sizeof(Node));
		p->data = rand()%100 +1;	//随机产生100以内的数字
		p->next = (*L)->next;	
		(*L)->next = p;			//插入到表头
	}
}

/*随机产生n个元素的值，建立带表头结点的单链线性表L(尾插法)*/
void CreateListTail(LinkList *L,int n){
	LinkList p,r;
	int i;
	
	srand(time(0));						//初始化随机数种子
	*L=(LinkList)malloc(sizeof(Node));	//L为整个线性表
	r = *L;								//r为指向尾部的结点

	for(i = 0;i < n ;i++){
		p->(Node)malloc(sizeof(Node));
		p->data = rand()%100+1;
		r->next = p;					//将表尾的终端节点的指针指向新结点
		r = p;							//将当前的新结点定义为表尾终端结点
	}
		r->next =(*L)->next->next;
}

//比较步数的方法 
int HasLoop1(LinkList L){
	LinkList cur1 = L;//定义结点 cur1
	int pos1 = 0; 		//cur1 的步数
	
	while(cur1){
		LinkList cur2 = L;				//定义结点cur2
		int pos2 = 0;					
		while(cur2){
			if(cur2 == cur1){			
				if(pos1 ==pos2)			//走过的步数一样
					break;				//说明没有环
				else{					//否则
					printf("环的位置在第%d个结点处：\n\n",pos2);
					return 1;			//有环并返回1
					}
				}
				cur2  = cur2->next;
				pos2 ++;				//cur2步数自增
			}
			cur1 = cur1->next;			//cur1继续向后一个结点
			pos1++;						//cur1步数自增
	}
			return 0;
}

//利用快慢指针
int HasLoop2（LinkList L）{
	int step1 = 1;
	int step2 = 2;
	LinkList p = L;
	ListList q = L;
	
	while(p !=NULL && q !=NULL && q->next !=NULL){
		p = p->next;
		if(q->next !=NULL)
			q = q->next->next;
		
		printf(“p:%d,q:%d\n”，p->data,q->data);
		
		if(p == q){
			return 1;
		}
		return 0;
	}

int main(){
	LinkList L;
	Status i;
	char opp;
	ElemType e;
	int find;
	int temp;
	
	i = InitList(&L);
	printf("初始化L后：ListLength(L)=%d\n",ListLength(L))

	printf("\n1.创建有环链表（尾插法） \n2创建无循环链表（头插法）\n3.判断链表是否有环")；
	while( opp !=''0){
		scanf("%c",&opp);
		switch(opp){
			case '1':
				CreateListTail(&L.20);
				printf("成功创建有环L（尾插法）\n");
				printf("\n");
				break;
			case '2':
				CreateListHead(&L,20); 
				printf("成功创建无环L（头插法）\n");
				printf("\n");
				break;
			case '3':
				printf("方法一：");
				if(HasLoop1(L)){
					printf("有环");
				}
				else{
					printf("无环");
				}
				printf("方法二：");
				if(HasLoop12(L)){
					printf("有环");
				}
				else{
					printf("无环");
				}
		}
	}
	
}

}

五、双向链表

1. 概述

有一个单链表的顺序为 A->B->C->D->E->F
我们此时已经查找到D，再想要查找到C。由双向链表可知，
必须由 D->E->F->A->B->C，过于麻烦
由此引入双向链表

2.双向链表的插入操作

小甲鱼笔记：数据结构——线性表（四）循环链表和双向链表，约瑟夫问题，魔术师发牌问题，判断一个单链表是否有环 - 文章图片

代码实现

s->next = p;
s->prior = p->prior;
p->prior->next = s;
p->prior = s;

3. 双向链表的删除操作

小甲鱼笔记：数据结构——线性表（四）循环链表和双向链表，约瑟夫问题，魔术师发牌问题，判断一个单链表是否有环 - 文章图片

代码实现

p->prior->next = p->next;
p->next->prior = p->prior;
free(p)

4. 小结

双向链表相对于单链表来说，是要更复杂一点，每个结点多了一个prior指针，对于插入和删除操作的顺序需要格外小心
双向链表有效算法的时间性能，即用空间换取时间

六、双向链表实战

要求实现用户输入一个数使得26个字母的排列发生变化
例如：用户输入3，输出结果为
DEFGHIJKLMNOPQRSTUVWXYZABC
代码实现

#include <stdio.h>
#include <stdlib.h>

#define OK 1
#define ERROR  0

typedef char ElemType;
typedef int  Status;//状态返回
typedef struct DualNode;//定义双向循环链表

typedef struct DualNode{
	ElemType data;
	struct DualNode *prior;
	struct DualNode *next;
}DualNode, *DuLinkList;

/*
* 
* 初始化循环链表
*/
Status InitList(DuLinkList *L) {
	DualNode *p, *q;
	int i;
	*L = (DuLinkList)malloc(sizeof(DualNode));
	if (!(*L)) {
		return ERROR;
	}
	(*L)->next = (*L)->prior = NULL;
	p = (*L);

	for ( i = 0; i < 26; i++)
	{
		q = (DualNode *)malloc(sizeof(DualNode));
		if (!q)
		{
			return ERROR;
		}
		q->data = 'A' + i;
		q->prior = p;
		q->next = p->next;	//p->next为NULL，让q->next = p->next ,此时q->next应当为NULL
		p->next = q;		//p->next 指向q结点

		p = q;				//让 p = q 让他们为同一个结点
	}
	p->next = (*L)->next;
	(*L)->next->prior = p;

	return OK;
}


void Caesar(DuLinkList *L, int i) {
	if (i > 0)
	{
		do
		{
			
			(*L) = (*L)->next;
		} while ( --i);
	}
	if (i < 0)
	{
		do 
		{
			(*L) = (*L)->next;
		} while (++i);
	}

}

int main() {
	DuLinkList L;
	int i,n;

	InitList(&L);
	printf("请输入一个整数：");
	scanf("%d",&n);
	printf("\n");
	Caesar(&L, n);
	for ( i = 0; i < 26; i++)
	{
		L = L->next;
		printf("%c",L->data);
	}
	return 0;
}

内容总结

以上是互联网集市为您收集整理的小甲鱼笔记：数据结构——线性表（四）循环链表和双向链表，约瑟夫问题，魔术师发牌问题，判断一个单链表是否有环全部内容，希望文章能够帮你解决小甲鱼笔记：数据结构——线性表（四）循环链表和双向链表，约瑟夫问题，魔术师发牌问题，判断一个单链表是否有环所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1030779.html

来源：【匿名】

【上一篇】数据挖掘心电图分类（三）之特征提取【下一篇】关于IE的RegExp.exec的问题

更多 ►

【小甲鱼笔记：数据结构——线性表（四）循环链表和双向链表，约瑟夫问题，魔术师发牌问题，判断一个单链表是否有环】教程文章相关的互联网学习教程文章

数据结构基础概念录

前言回忆与自我理解迭代概念数据: 什么是数据? 是描述客观事物的符合，是计算机中可以操作的对象，是能被计算机识别，并输入给计算机处理的符号集合。个人理解:以人来说，把人感知的一切都叫做数据，比如说树、花。他们在我们心中代表一种符号。但是并不代表我们不认识的，就不叫数据，他们在我们心中的符合是不认识，这依然是一个符合。数据元素：是组成数据的、有一定意义的基本单位，在计算机中通常作为整体处理。这个比较抽象，...

6-13知识点：数据结构——图【代码】【图】

拓扑排序一.基础知识 1.AOV网（用顶点表示活动的网）（Activity On Vertex NetWork）用DAG图（有向无环图）表示?个工程，顶点表示活动，有向边<Vi, Vj>表示活动Vi必须先于活动Vj进行因此：AOV网一定是有向无环图如：番茄炒蛋的AOV网 2.拓扑排序把顶点排成一排，且必须满足以下条件（1）每个顶点出现且只出现一次（2）AOV网中A→B，表示拓扑排序中A排在B之前这种序列成为原图的一个拓扑排序注：（1）有向无环图才有拓扑...

（5.3.4）数据库迁移——数据结构对比【代码】【图】

【1】数据结构对比（实例内）但不建议使用，建议使用 red Gate 工具集中的 SQL Compare 但如果没有装软件，可以使用脚本实现/*作用，1.对比2个库字段类型是否相同2.对比2个库字段数量是否相同*/ --（1）主从表字段差异与表结构差异 use db_del goif object_id(temp_logs1) is not nulldrop table temp_logs1if object_id(temp_logs2) is not nulldrop table temp_logs2if object_id(temp_tank1) is not nulldrop table temp_tank1...

HashMap的数据结构【图】

一HashMap的数据结构 jdk1.8以前是数组+链表jdk1.8以后是数组+链表+红黑色二数据结构的物理结构是指数据的逻辑结构在计算机中的存储形式数据元素的存储结构形式有如下两种：顺序存储结构：是把数据元素存放在地址连续的存储单元里，其数据间的逻辑关系和物理关系是一致的链式存储结构：是把数据元素存放在任意的存储单元里，这组存储单元可以是连续的，也可以是不连续的，那么我们如何找到它呢，我们会把一个指针存放在数据元素...

数据结构第六章小结【代码】【图】

邻接矩阵#define MNNum 100//最大顶点数 typedef char VerTexTypre;//顶点的数据类型 typedef int ArcType;//顶点的权值类型 typedef struct {VerTexType vexs[MVNum];//顶点表ArcType arcs[MVNum][MVNum];//邻接矩阵int vexnum, arcnum;//图的点数和边数 }AMGraph;邻接表#define MVNum 100//最大顶点数 typedef struct ArcNode//边结点{int adjvex;//该边的顶点位置struct ArcNode *nextarc;//指向下一条边的指针otherInfo info;/...

数据结构线性栈【代码】

#ifndef _MY_LINKSTACK_H_ #define _MY_LINKSTACK_H_typedef void LinkStack;//创建链表栈 LinkStack* LinkStack_Create();//销毁链表栈int LinkStack_Destroy(LinkStack** stack);//清空链表栈int LinkStack_Clear(LinkStack* stack);//压栈int LinkStack_Push(LinkStack* stack, void* item);//出栈void* LinkStack_Pop(LinkStack* stack);//获取栈顶元素void* LinkStack_Top(LinkStack* stack);//获取栈的大小int LinkStack_Siz...

数据结构 - 几种常见的排序方法【图】

排序：分类：稳定和不稳定的排序：假设一组排序中有两个相同的数字，排序前后排序后两个数字的先后顺序不变；不稳定的排序则有可能发生改变。内排序和外排序：内排序指的是在内存中排序，外排序则涉及到外部的存储空间排序方法：排序方法又分为很多种有：插入类排序，交换类排序，选择类排序，归并排序，基数排序插入排序又分为：直接插入排序，折半插入排序，2-路插入排序，表插入排序和希尔排序等。直接插入排序：简...

《程序设计与数据结构》第四周学习总结

学号 20172326 《程序设计与数据结构》第四周学习总结教材学习内容总结列表与栈，队列的关系与区别有序列表插入时插入方法无序列表的区别 Comparable方法的重载用链表，数组实现列表教材学习中的问题和解决过程问题1：问题1理解：XXXXXX 问题2：XXXXXX 问题2理解：XXXXXX ... 代码调试中的问题和解决过程问题1：XXXXXX 问题1解决方案：XXXXXX 问题2：XXXXXX 问题2解决方案：XXXXXX ... 代码托管上周考试错题总结错题1及原因，...

20172322 2017-2018-2《程序设计与数据结构》课程总结【图】

20172322 2018-2019-1《程序设计与数据结构》课程总结每周作业链接汇总第一次作业：什么叫高质量软件；学习教材1、2章节。第二次作业：学习教材3、4章节，栈相关知识的学习，利用数组和链实现栈。第三次作业：学习教材第5章，队列相关知识的学习；完成技能调查表。第四次作业：学习教材第6章，列表相关只是的学习，有序列表、无序列表、索引列表等。第五次作业：学习教材第9章，选择与排序相关知识的学习。第六次作业：学习教...

20172313 2018-2019-1 《程序设计与数据结构》第四周学习总结【代码】【图】

20172313 2018-2019-1 《程序设计与数据结构》第四周学习总结教材学习内容总结列表集合有序列表：其元素按照元素的某种内在特性进行排序。（有序列表中的元素具有内在关联，这种关联定义了元素之间的顺序）无序列表：其元素间不具有内在顺序，元素按照它们在列表中的位置进行排序。（无序列表中的元素按使用者所选择的任意方式排序）索引列表：其元素可以用数字索引来引用。（索引列表为它的元素维护一段连续的数字索引值）J...

冷月手撕408之数据结构(2)-数据结构绪论【图】

数据结构绪论不是考纲的重点，但是一定要会求时间复杂度，这是必考的一个点。初试不考复试也会考，所以必须要会求。其他的概念有一个了解。主要的重点冷月做出了标识，主要构架如下图（pdf版或xmind源文件请私聊我：数据结构）。冷月点睛数据结构绪论数据结构定义：在计算机中数据之间的存储关系逻辑结构有线性结构（线性表、栈、队列）,非线性结构(树、图)存储结构顺序存储：逻辑上连续，物理上也连续链式存储：逻辑上连续，物理...

每天3分钟操作系统修炼秘籍（23）：进程表和进程数据结构【代码】【图】

点我查看秘籍连载进程表和进程数据结构内核负责管理维护所有进程，为了管理进程，内核在内核空间维护了一个称为进程表（Process Table）的数据结构，这个数据结构中记录了所有进程，每个进程在数据结构中都称为一个进程表项（Process Table Entry），如图。从图中可知，进程表中除了记录了所有进程的PID，还使用一个字段记录了所有进程的指针，指向每个进程的进程控制块（Process Control Block，PCB），请记住PCB这个词，它太重...

【数据结构从青铜到王者】第七篇:数据结构之堆【代码】【图】

系列文章目录文章目录系列文章目录前言一、堆的概念二、堆的性质三、堆的实现1.用数组定义堆结构struct Heap2.交换两个数Swap函数3.向下调整算法AdjustDown函数4.向上调整算法AdjustUp函数5.初始化堆HeapInit函数6.销毁堆HeapDestory函数7.堆的插入HeapPush函数8.堆的删除HeapPop函数9.取堆顶数据 HeapTop函数10.取堆数据个数 HeapSize函数11.堆判空 HeapEmpty函数12.打印堆HeapPrint函数总结前言一、堆的概念如果有一个关键码的...

【数据结构】双链表【代码】【图】

#include<iostream> #include<cstdlib> using namespace std; typedef struct DuLNode {int data;DuLNode *prior,*next; }; void InitSList(DuLNode *&SL) {//初始化双链表 SL=(DuLNode*)malloc(sizeof(DuLNode));SL->prior=SL->next=NULL; } void createSList(DuLNode *&SL) {//创建双链表 DuLNode *s,*r;r=SL;while(1) {s=( DuLNode*)malloc(sizeof(DuLNode)); cin>>s->data; if(s->data==-1)break;r->next=s;s->prior=r;r=s;...

数据结构-栈【代码】【图】

part 5栈 1 概念 1.1 现象弹夹式手枪、洗盘子摞盘子、浏览器回退功能、word、画图的撤销操作 1.2 特点原理：后进先出（LIFO结构） 1 .3 定义栈：限定在表尾进行插入（尾插法）或删除操作的线性表栈顶（表尾）允许插入和删除的一端称为栈顶（top），另一端称为栈底(bottom)。空栈不含任何数据元素的栈。压栈（进栈）：栈的插入出栈：栈的删除 1.4 逻辑示意图 1.5 进栈出栈变化形式最先进栈的只能最后出栈？解析：栈对线...

首页 / 更多教程 / 小甲鱼笔记：数据结构——线性表（四）循环链表和双向链表，约瑟夫问题，魔术师发牌问题，判断一个单链表是否有环

小甲鱼笔记：数据结构——线性表（四）循环链表和双向链表，约瑟夫问题，魔术师发牌问题，判断一个单链表是否有环

内容导读

内容图文

一、循环链表

1. 背景

2.初始化循环链表

3. 循环链表的插入

4. 循环链表的删除

5. 返回结点所在的位置

二、约瑟夫问题

1.问题提出

2. 代码实现

三、循环链表的特点

1、例题：实现将两个线性表（a1,a2,…,an）和（b1,b2,…,bm）连接成一个线性表（）a1,…,an,b1,…,bm)的运算

2、代码实现

四、判断单链表是否有环

五、双向链表

1. 概述

2.双向链表的插入操作

3. 双向链表的删除操作

4. 小结

六、双向链表实战

内容总结

内容备注

内容手机端

【小甲鱼笔记：数据结构——线性表（四）循环链表和双向链表，约瑟夫问题，魔术师发牌问题，判断一个单链表是否有环】教程文章相关的互联网学习教程文章

更多教程 - 最新教程

更多教程 - 最热教程