图解循环链表

最新推荐文章于 2023-01-04 22:21:28 发布
最新推荐文章于 2023-01-04 22:21:28 发布
阅读量1k 收藏 2
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WUZHU2017/article/details/108516459
版权

 

插入的3种场景：

第一种：

第二种：

第三种：

 

删除的3种场景 

优点：功能强了。
    循环链表只是在单链表的基础上做了一个加强
    循环链表可以完全取代单链表的使用
    循环链表的Next和Current操作可以高效的遍历链表中的所有元素
缺点：
    代码复杂度提高了

 

 

#ifndef _KNCIRCLELIST_H_
#define _KNCIRCLELIST_H_
/*
	带有头结点的循环链表
	循环链表的定义：将单链表中最后一个数据元素的next指针指向第一个元素
*/

//定义为void 
typedef void CircleList;

typedef struct _tag_CircleListNode
{
	struct _tag_CircleListNode *next;
}CircleListNode;


//创建循环链表
CircleList* CircleList_Create();

//销毁循环链表
void CircleList_Destroy(CircleList* list);

//清空循环链表
void CircleList_Clear(CircleList* list);

//获取循环链表长度
int CircleList_Length(CircleList* list);

//向循环链表的pos位置插入node节点
int CircleList_Insert(CircleList* list, CircleListNode* node, int pos);

//获取pos位置的节点
CircleListNode* CircleList_Get(CircleList* list, int pos);

//删除pos位置的节点
CircleListNode* CircleList_Delete(CircleList* list, int pos);

/*
	相对于单链表来说,循环链表新的操作 

	新增功能：游标的定义
		在循环链表中可以定义一个“当前”指针，这个指针通常称为游标，
		可以通过这个游标来遍历链表中的所有元素。
*/

//直接指定删除链表中的某个数据元素
CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node);

//将游标重置指向链表中的第一个元素
CircleListNode* CircleList_Reset(CircleList* list);

//获取当前游标指向的元素
CircleListNode* CircleList_Current(CircleList* list);

//将游标移动指向到链表中的下一个元素
CircleListNode* CircleList_Next(CircleList* list);

#endif

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "knDebug.h"
#include "knCirclelist.h"

typedef struct _tag_CircleList
{
	CircleListNode header;	//头指针
	CircleListNode *slider;	//游标("当前指针")
	int length;				//链表长度
}TCircleList;

//创建循环链表
CircleList* CircleList_Create()
{
	TCircleList *ret = (TCircleList*)malloc(sizeof(TCircleList));
	if (ret == NULL){
		DEBUG("ret == NULL\n");
		return NULL;
	}
	ret->length = 0;
	ret->header.next = NULL;
	ret->slider = NULL;
	return ret;
}

//销毁循环链表
void CircleList_Destroy(CircleList* list)
{
	if (list == NULL)
	{
		return;
	}
	free(list);
}

//清空循环链表
void CircleList_Clear(CircleList* list)
{
	TCircleList *sList = (TCircleList *)list;
	sList->length = 0;
	sList->header.next = NULL;
	sList->slider = NULL;

}

//获取循环链表长度
int CircleList_Length(CircleList* list)
{
	TCircleList *sList = (TCircleList*)list;
	int ret = -1;
	if (list == NULL){
		DEBUG("ret == NULL\n");
		return ret;
	}
	ret = sList->length;
	return ret;
}

//向循环链表的pos位置插入node节点
int CircleList_Insert(CircleList* list, CircleListNode* node, int pos)
{
	int ret = 0, i = 0;
	TCircleList *sList = (TCircleList*)list;
	if (list == NULL || node == NULL || pos < 0){
		DEBUG("list == NULL || node == NULL || pos < 0\n");
		return -1;
	}
	//将辅助指针变量指向头部
	CircleListNode* current = (CircleListNode*)sList;

	for (i = 0; i < pos && current->next != NULL; i++){
		current = current->next;
	}
	//第1种场景 普通的插入且 current->next != NULL 12
	//第2种场景 从无到有的尾部插入                  12
	//第3种场景 头插法                             123
	node->next = current->next;	//1
	current->next = node;		//2

	//若是第一次插入节点 即从无到有的尾部插入
	if (sList->length == 0){
		sList->slider = node;//指向pos为0的节点 游标的初始值
	}
	sList->length++;
	//若是头插法,current仍然指向头部 原因是跳0步,没有跳走
	if (current == (CircleListNode *)sList){//本语句是判断头插法
		CircleListNode *last = CircleList_Get(sList, sList->length - 1);//3
		last->next = current->next;//3 此时的current->next 已经是node节点了 76行
	}
	return ret;
}

//获取pos位置的节点
CircleListNode* CircleList_Get(CircleList* list, int pos)
{
	TCircleList *sList = (TCircleList*)list;
	CircleListNode *ret = NULL;
	int i = 0;

	if (sList == NULL || pos < 0){
		return NULL;
	}
	//让辅助指针变量指向头部
	CircleListNode *current = (CircleListNode*)sList;
	for (i = 0; i < pos; i++){
		current = current->next;
	}
	ret = current->next;
	return ret;
}

//删除pos位置的节点
CircleListNode* CircleList_Delete(CircleList* list, int pos)
{
	TCircleList *sList = (TCircleList*)list;
	CircleListNode *ret = NULL;
	int i = 0;

	if (sList != NULL && pos >= 0 && sList->length > 0)
	{
		CircleListNode *current = (CircleListNode*)sList;
		CircleListNode *last = NULL;
		for (i = 0; i < pos; i++){
			current = current->next;
		}
		//若删除第一个元素，则涉及到尾部元素了,作为辅助指针变量
		if (current == (CircleListNode*)sList){
			last = (CircleListNode*)CircleList_Get(sList, sList->length - 1);
		}
		//缓存要删除的元素
		ret = current->next;
		current->next = ret->next;
		sList->length--;

		//说明删除的是第一个元素
		if (last != NULL){//
			sList->header.next = ret->next;  //头节点指向链表的新的首元素
			last->next = ret->next;          //链表的尾部元素指向首元素
		}
		//若删除的元素为游标所指的元素
		if (sList->slider == ret){
			sList->slider = ret->next;//将游标指向当前节点
		}
		//若删除元素后,链表长度为0
		if (sList->length == 0){
			sList->header.next = NULL;
			sList->slider = NULL;
		}
	}
	return ret;
}

/*
	游标的定义
	在循环链表中可以定义一个“当前”指针，这个指针通常称为游标，
	可以通过这个游标来遍历链表中的所有元素。
*/
//直接指定删除链表中的某个数据元素
CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node)
{
	TCircleList* sList = (TCircleList*)list;
	CircleListNode *ret = NULL;
	int i = 0;
	if (sList != NULL)
	{
		CircleListNode *current = (CircleListNode*)sList;
		//查询node在链表中的位置
		for (i = 0; i < sList->length; i++){
			if (current->next == node){
				ret = current->next;//找到了缓存下来
				break;
			}
			current = current->next;
		}
		if (ret != NULL){
			CircleList_Delete(sList, i);
		}
	}
	return ret;
}

//将游标重置指向链表中的第一个元素
CircleListNode* CircleList_Reset(CircleList* list)
{
	TCircleList *sList = (TCircleList*)list;
	CircleListNode *ret = NULL;
	if (sList != NULL){
		sList->slider = sList->header.next;
		ret = sList->slider;
	}
	return ret;
}

//获取当前游标指向的元素
CircleListNode* CircleList_Current(CircleList* list)
{
	TCircleList *sList = (TCircleList*)list;
	CircleListNode *ret = NULL;
	if (sList != NULL){
		ret = sList->slider;
	}
	return ret;
}

//将游标当前指向的元素返回,将游标移动指向到链表中的下一个元素
CircleListNode* CircleList_Next(CircleList* list)
{
	TCircleList *sList = (TCircleList*)list;
	CircleListNode *ret = NULL;
	if ((sList != NULL) && (sList->slider != NULL)){
		ret = sList->slider;
		sList->slider = ret->next;
	}
	return ret;
}
#include <stdlib.h>
#include <stdio.h>
#include "knCirclelist.h"
#include "knDebug.h"

typedef struct Value{
	CircleListNode circlenode;
	int v;
	char name[64];
}Value;

void test()
{
	CircleList *list = CircleList_Create();
	Value v1, v2, v3, v4, v5, v6, v7, v8;
	v1.v = 1;
	v2.v = 2;
	v3.v = 3;
	v4.v = 4;
	v5.v = 5;
	v6.v = 6;
	v7.v = 7;
	v8.v = 8;

	CircleList_Insert(list, (CircleList*)&v1, 0);//头插法 游标始终指向位置为0的元素
	CircleList_Insert(list, (CircleList*)&v2, 0);
	CircleList_Insert(list, (CircleList*)&v3, 0);
	CircleList_Insert(list, (CircleList*)&v4, 0);

	//如何证明是循环链表 打印2倍的链表长度 若元素一样，则证明是循环链表
	printf("------证明是循环链表------\n");
	for (int i = 0; i < 2 * CircleList_Length(list); i++){
		//将节点取出来转换为业务节点
		Value *pv = (Value*)CircleList_Get(list, i);
		printf("%d\n", pv->v);
		if (i == CircleList_Length(list) - 1){
			printf("------第2遍------\n");
		}
	}

	printf("------游标操作------\n");
	//获取当前游标指向的元素
	Value *current = (Value*)CircleList_Current(list);
	printf("1-当前游标     指向的值 %d\n", current->v);
	//将游标移动指向到链表中的下一个元素
	Value *before = (Value*)CircleList_Next(list);
	printf("2-游标移动之前 指向的值 %d\n", before->v);
	current = (Value*)CircleList_Current(list);
	printf("3-游标移动之后 指向的值 %d\n", current->v);
	//直接指定删除链表中的某个数据元素
	Value *deleteNode = (Value *)CircleList_DeleteNode(list, (CircleList*)&v1);
	printf("4-删除指定的元素%d: 函数返回删除的指定元素%d\n", v1.v, deleteNode->v);

	//通过游标遍历循环链表
	printf("---------使用游标遍历 循环链表---------\n");
	int length = CircleList_Length(list);
	int i = 0;
	for (Value *it = (Value*)CircleList_Current(list); i < length; CircleList_Next(list), i++){
		Value * current = (Value*)CircleList_Current(list);
		printf("%d ", current->v);
	}
	printf("\n");

	printf("---------删除 循环链表---------\n");
	while (CircleList_Length(list) > 0){
		Value * ret = (Value *)CircleList_Delete(list, 0);//删除第一个元素
		printf("删除的元素为%d\n", ret->v);
	}

	printf("\n");
	CircleList_Destroy(list);

}

int main()
{
	test();
	system("pause");
	return 0;
}

 

 

 

吾竹清风
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
循环链表
a4647520的专栏
08-12 544
单链的循环链表结点的存储结构和单链表的存储结构一样，所不同的是：最后一个结 点的next 域指向头结点，而不是“空”。这样，由表尾很容易找到表头。但若链表较长， 则由表头找到表尾较费时，因而，单循环链表往往设立尾指针而不是头指针，如图231 所示。这在两个链表首尾相连合并成一个链表时非常方便。Bo2-4.cpp 是设立尾指针的单 循环链表的基本操作。
数据结构——“双向循环链表“ 易懂刨析双向循环链表（图解+代码）
热门推荐
weixin_44278698的博客
04-27 1万+
循环链表单向循环链表双向循环链表1. 双向循环链表——插入2. 双向循环链表——删除 单向循环链表 关于两个循环链表合并为一个循环链表 双向循环链表 在单链表L中，查找ai的后继Next(L，a;)，耗时仅为O(1)，因为取ai后继指针即可。 但查找a;的直接前驱Prior(L，ai);则需从链表的头指针开始，找到结点ai前一结点即是。故运算Prior(L，ai)依赖表长n，耗时为O(n)。另外，若链表中有一指针值被破坏，则整个链表脱节。这是单链表的不足 为此，引入双向链表。先定义双向链表中的结点:
图解：链式存储结构之循环链表（修订版）
墨鱼菜鸡
09-09 457
点击关注上方“五分钟学算法”， 设为“置顶或星标”，第一时间送达干货。 转自景禹 循环，顾名思义就是：绕。 打个比方，就是从前山上有座庙，庙里有个老和尚和一个小和尚，有一天老和尚对小和尚说“从前山上有座庙，庙里有个老和尚和一个小和尚，有一天老和尚对小和尚说“从前~~ 对于单链表，由于每个结点只存储了向后的指针，到了尾部标识就停止了向后...
【数据结构】线性表-循环链表（图解、c++、java）
扑腾的江鱼复习仓库
01-17 1866
URLeisure的循环链表“完美”复习资料。
链表图解（双向、循环链表+链表增删）
qq_52189899的博客
11-26 3013
补充介绍双向链表和循环链表，并用具体图像讲述了链表的增加和删除。
双向循环链表的讲解及实现（图解+代码/C语言）
最新发布
qq_62306969的博客
01-04 3759
本文主要分享了双向循环链表（带头）的写法，使用C语言完成，文中附有具体的结构图片帮助大家理解，希望对大家有帮助
jdk1.7 HashMap中的致命错误：循环链表
12-21
《深入解析JDK1.7 HashMap的循环链表问题》 HashMap作为Java中常用的数据结构，其高效性和灵活性深受开发者喜爱。然而，在JDK1.7版本中，HashMap存在一个严重的问题，即“循环链表”（Looping List），这可能导致在...
图解数据结构（使用Python）——链表
12-21
在循环链表中插入节点的操作与单向链表类似，但考虑到循环特性，插入位置的选择更为重要。 总的来说，链表作为数据结构的重要组成部分，它的特性使得它在某些特定场景下优于其他数据结构，如数组。理解并熟练掌握...
双向链表API及C语言实现
03-29
双向链表的API和C语言...另外还有线性表顺序存储、单链表、循环链表的C语言实现，文章及代码资源均已上传，可在专栏《数据结构与算法学习笔记》中查看，欢迎大家查看下载，如果内容有不合理的地方，欢迎大家批评指正。
图解数据结构C++版源码
01-13
链表分为单向链表、双向链表和循环链表等类型，它们在内存管理上比数组更加灵活，适合频繁的插入和删除操作。 2. **栈**：栈是一种后进先出（LIFO）的数据结构，通常用于实现函数调用、表达式求值等场景。C++中，`...
选择排序在链表中的实现图解PPT学习教案.pptx
10-11
链表的选择排序主要分为两个阶段：外循环和内循环。外循环负责遍历整个链表，每次处理一个基准点。内循环则负责在基准点之后的子链表中找到最小元素，并将其调整到基准点之前。 1. 初始化： - `q` 指针始终指向...
循环链表详解(循环单链表/循环双链表)
Curz酥的博客
10-05 1万+
王道数据结构笔记
一文弄懂循环链表、双向链表、静态链表
weixin_46002185的博客
01-12 3077
静态链表、循环链表、双向链表 单链表请点击这里 1.静态链表 C语言具有指针这一强大的功能，也是众多计算机领域的人用来描述数据结构首选C语言的原因之一。指针可以使C非常容易的操作内存中的地址和数据，这比其他高级语言更加灵活方便。Java、C#等面向对象语言，虽然不使用指针，但因为启用了对象引用机制，从某种角度也间接实现了指针的某些作用。但对于其他一些语言，如Basic、Fortran等早期的编程语言对于一些数据结构的操作就没有那么方便了。 有前辈想出来用数组来代替指针，描述单链表：首先让数组的元素都是由两个
循环链表的操作详解
lixin_com的博客
09-13 4548
一、概述 循环链表：循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。 从上图看出循环链表有两个成员：data 和 next 由此可创建循环链表和它的一些基本操作如下： 注明：它的操作其实与单链的操作差不多，只要注意判断标志即可。 #pragma once //循环链表,尾节点的next指向头 typedef struct C
循环双链表详解（C语言版）
qq_44075108的博客
10-22 1万+
之前学习的双链表结构，可以实现从表中任一结点出发找到链表中的其他结点，但是该结构如果要从头结点开始查找尾结点，那么就需要通过遍历查找尾结点，这种情况下双链表的效率较低，为了解决这个缺点，将其改进为循环双链表，以此来提高查找效率。
【数据结构入门】带头双向循环链表（List）详解（定义、增、删、查、改） | 配有大量图解，超详细哦~
codewinter的博客
09-10 2025
文章目录（1）前言（2）带头双向循环链表的实现1）双向链表的定义2）双向链表的初始化3）双向链表的销毁4）打印双向链表5）双向链表的尾插6）双向链表的尾删7）双向链表的头插8）双向链表的头删9）查找双向链表中的元素10）在指定pos位置之前插入元素11）删除指定pos位置的元素12）双向链表的判空13）获取双向链表的元素个数 学习双向链表之前，建议先学习下顺序表和单链表，配合这两篇文章食用更佳哦： 【数据结构入门】顺序表（SeqList）详解（初始化、增、删、查、改） 【数据结构入门】无头单向非循环链表（S
数据结构-循环链表
wooovi的博客
02-07 987
循环链表 循环链表:是一种头尾相接的链表（即:表中最后一个结点的指针域指向头结点，整个链表形成一个环)。 优点:从表中任一结点出发均可找到表中其他结点。 注意: 由于循环链表中没有NULL指针，故涉及遍历操作时，其终止条件就不再像非循环链表那样判断p或p->next是否为空，而是判断它们是否等于头指针。 合并带尾指针的循环链表 【操作步骤】 p存表头结点 p=Ta->next; Tb表头连接到Ta表尾 Ta->next=Tb->next->next ; 释放Tb表头结点
图解线性表的顺序存储结构
吾竹清风2017
09-07 1284
#ifndef __KNSEQLIST_H__ #define __KNSEQLIST_H__ typedef void SeqList; typedef void SeqListNode; //创建线性表 SeqList * SeqList_Create(int capacity); //销毁线性表 void SeqList_Destroy(SeqList *list); //清空线性表 void SeqList_Clear(SeqList *list); //获取线性表的长...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值