4--循环链表

最新推荐文章于 2024-06-29 00:19:58 发布
最新推荐文章于 2024-06-29 00:19:58 发布
阅读量2.3k 收藏 2
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/syc434432458/article/details/51190665
版权

1、基本概念

循环链表的定义：将单链表中最后一个数据元素的next指针指向第一个元素


循环链表拥有单链表的所有操作:

创建链表

销毁链表

获取链表长度

清空链表

获取第pos个元素操作

插入元素到位置pos

删除位置pos处的元素

游标的定义

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


循环链表新操作:

获取当前游标指向的数据元素

将游标重置指向链表中的第一个数据元素

将游标移动指向到链表中的下一个数据元素

直接指定删除链表中的某个数据元素

2、设计与实现

插入元素的分析

  1. 普通位置插入元素
  2. 添加第一个元素（第一次插入元素）
  3. 最后一个位置插入元素
  4. 第一个位置插入元素(如图):

添加第一个元素如图：

在最后一个位置插入元素如图：

删除节点

3、优点和缺点

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

缺点：代码复杂度提高了

约瑟夫问题-循环链表典型应用

n 个人围成一个圆圈，首先第 1 个人从 1 开始一个人一个人顺时针报数，报到第 m 个人，令其出列。然后再从下一个人开始从 1 顺时针报数，报到第 m 个人，再令其出列，…，如此下去，求出列顺序。


CircleList.h 

#ifndef _CIRCLELIST_H_

#define _CIRCLELIST_H_

typedef void CircleList;

/*

typedef struct _tag_CircleListNode CircleListNode;

struct _tag_CircleListNode

{

CircleListNode* next;

};

*/

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);

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos);

CircleListNode* CircleList_Get(CircleList* list, int pos);

CircleListNode* CircleList_Delete(CircleList* list, int pos);

//add

CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node);

CircleListNode* CircleList_Reset(CircleList* list);

CircleListNode* CircleList_Current(CircleList* list);

CircleListNode* CircleList_Next(CircleList* list);

#endif


CircleList.c

#include <stdio.h>

#include <malloc.h>

#include "CircleList.h"

typedef struct _tag_CircleList

{

 CircleListNode header;

 CircleListNode* slider;

 int length;

} TCircleList;

CircleList* CircleList_Create() // O(1)

{

 TCircleList* ret = (TCircleList*)malloc(sizeof(TCircleList));

 if (ret == NULL)

 {

  return NULL;

 }

 

 ret->length = 0;

 ret->header.next = NULL;

 ret->slider = NULL;

 return ret;

}

void CircleList_Destroy(CircleList* list) // O(1)

{

 if (list == NULL)

 {

  return ;

 }

 free(list);

}

void CircleList_Clear(CircleList* list) // O(1)

{

 TCircleList* sList = (TCircleList*)list;

 if (sList == NULL)

 {

  return ;

 }

 sList->length = 0;

 sList->header.next = NULL;

 sList->slider = NULL;

}

int CircleList_Length(CircleList* list) // O(1)

{

 TCircleList* sList = (TCircleList*)list;

 int ret = -1;

 if (list == NULL)

 {

  return ret;

 }

 ret = sList->length;

 return ret;

}

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos) // O(n)

{

 int ret = 0, i=0;

 TCircleList* sList = (TCircleList*)list;

 if (list == NULL || node== NULL || pos<0)

 {

  return -1;

 }

 //if( ret )

 {

  CircleListNode* current = (CircleListNode*)sList;

  for(i=0; (i<pos) && (current->next != NULL); i++)

  {

   current = current->next;

  }

  //current->next 0号节点的地址

  node->next = current->next; //1

  current->next = node; //2

  //若第一次插入节点

  if( sList->length == 0 )

  {

   sList->slider = node;

  }

  sList->length++;

  //若头插法

  if( current == (CircleListNode*)sList )

  {

   //获取最后一个元素

   CircleListNode* last = CircleList_Get(sList, sList->length - 1);

   last->next = current->next; //3

  }

 }

 return ret;

}

CircleListNode* CircleList_Get(CircleList* list, int pos) // O(n)

{

 TCircleList* sList = (TCircleList*)list;

 CircleListNode* ret = NULL;

 int i = 0;

 if (list==NULL || pos<0)

 {

  return NULL;

 }

 //if( (sList != NULL) && (pos >= 0) && (sList->length > 0) )

 {

  CircleListNode* current = (CircleListNode*)sList;

  for(i=0; i<pos; i++)

  {

   current = current->next;

  }

  ret = current->next;

 }

 return ret;

}

CircleListNode* CircleList_Delete(CircleList* list, int pos) // O(n)

{

 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) // O(n)

{

 TCircleList* sList = (TCircleList*)list;

 CircleListNode* ret = NULL;

 int i = 0;

 if( sList != NULL )

 {

  CircleListNode* current = (CircleListNode*)sList;

 

  //查找node在循环链表中的位置i

  for(i=0; i<sList->length; i++)

  {

   if( current->next == node )

   {

    ret = current->next;

    break;

   }

   current = current->next;

  }

 

  //如果ret找到，根据i去删除

  if( ret != NULL )

  {

   CircleList_Delete(sList, i);

  }

 }

 return ret;

}

CircleListNode* CircleList_Reset(CircleList* list) // O(1)

{

 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) // O(1)

{

 TCircleList* sList = (TCircleList*)list;

 CircleListNode* ret = NULL;

 if( sList != NULL )

 {

  ret = sList->slider;

 }

 return ret;

}

CircleListNode* CircleList_Next(CircleList* list) // O(1)

{

 TCircleList* sList = (TCircleList*)list;

 CircleListNode* ret = NULL;

 if( (sList != NULL) && (sList->slider != NULL) )

 {

  ret = sList->slider;

  sList->slider = ret->next;

 }

 return ret;

}


#include <stdio.h>

#include <stdlib.h>

#include "CircleList.h"

struct Value

{

 CircleListNode header;

 int v;

};

void  main()

{

 int i = 0;

 CircleList* list = CircleList_Create();

 struct Value v1;

 struct Value v2;

 struct Value v3;

 struct Value v4;

 struct Value v5;

 struct Value v6;

 struct Value v7;

 struct Value 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, (CircleListNode*)&v1, CircleList_Length(list));

 CircleList_Insert(list, (CircleListNode*)&v2, CircleList_Length(list));

 CircleList_Insert(list, (CircleListNode*)&v3, CircleList_Length(list));

 CircleList_Insert(list, (CircleListNode*)&v4, CircleList_Length(list));

 CircleList_Insert(list, (CircleListNode*)&v5, 5);

 CircleList_Delete(list, 0);

 for(i=0; i<2*CircleList_Length(list); i++)

 {

  struct Value* pv = (struct Value*)CircleList_Get(list, i);

  printf("%d\n", pv->v);

 }

 printf("\n");

 while( CircleList_Length(list) > 0 )

 {

  struct Value* pv = (struct Value*)CircleList_Delete(list, 0);

  printf("%d\n", pv->v);

 }

 printf("\n");

 CircleList_Insert(list, (CircleListNode*)&v1, CircleList_Length(list));

 CircleList_Insert(list, (CircleListNode*)&v2, CircleList_Length(list));

 CircleList_Insert(list, (CircleListNode*)&v3, CircleList_Length(list));

 CircleList_Insert(list, (CircleListNode*)&v4, CircleList_Length(list));

 CircleList_Insert(list, (CircleListNode*)&v5, CircleList_Length(list));

 CircleList_Insert(list, (CircleListNode*)&v6, CircleList_Length(list));

 CircleList_Insert(list, (CircleListNode*)&v7, CircleList_Length(list));

 CircleList_Insert(list, (CircleListNode*)&v8, CircleList_Length(list));

 for(i=0; i<CircleList_Length(list); i++)

 {

  struct Value* pv = (struct Value*)CircleList_Next(list);

  printf("%d\n", pv->v);

 }

 printf("\n");

 CircleList_Reset(list);

 while( CircleList_Length(list) > 0 )

 {

  struct Value* pv = NULL;

  for(i=1; i<3; i++)

  {

   CircleList_Next(list);

  }

  pv = (struct Value*)CircleList_Current(list);

  printf("%d\n", pv->v);

  CircleList_DeleteNode(list, (CircleListNode*)pv);

 }

 CircleList_Destroy(list);

 system("pause");

 return ;

}



何时成为大牛
关注
专栏目录
顺序表和带头双向循环链表的优缺点
li1829146612的博客
03-26 1024
这二个结构其实是，相辅相成的结构 顺序表的优点 1.物理空间是连续的，方便用下标来访问（但这其实也算是它的缺点，效率比较低） 2.cpu高速缓存命中率更高 cpu不会直接访问内存，因为它会嫌弃内存访问太慢，通常都是把数据加载到缓存或寄存器里面，但是由于寄存器不算多，所以特别大的数据是加载在缓存里面的 cpu会看数据在不在缓存在就叫命中，直接访问，不在就不命中，先把数据加载到缓存在访问 那么cpu访问有个局部性原理，会访问这个局部，当这个不命中会把下一个局部加载到缓存里，由于顺序表的物理空间是连续
循环链表的特点
weixin_34356310的博客
12-12 1216
循环链表的特点 转载于:https://www.cnblogs.com/LoveFishC/archive/2012/12/12/3846808.html
数据结构-循环链表和双向链表
pyc68的博客
06-29 860
本篇文章介绍数据结构中的循环链表和双向链表
C语言——双向带头循环链表的增删查改及优缺点
weixin_47460769的博客
02-02 3242
文章目录前言一、双向带头循环链表1.双向带头循环链表结构1.双向带头循环链表实现代码二、双向带头循环链表优缺点1.双向带头循环链表优缺点2.顺序表优缺点 前言 链表的结构有很多种，其中用的比较多的就是单向不带头不循环链表和双向带头循环链表，这两种链表都有各自应用的场合。 双向带头循环链表结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。今天就用C语言来实现一下带头双向链表的增删查改。 一、双向带头循环链表 1.双向带头循环链表结构 首先：来看一下双向带头循环链表的结构
数据结构 —— 顺序表和链表（带头双向循环链表）的优缺点、以及CPU高速缓存命中率
wihkum
07-21 750
数据结构 —— 顺序表和链表（带头双向循环链表）的优缺点 + CPU缓存的知识。
特殊的链表——循环链表
kxbdys的博客
04-04 2161
一、循环链表的概述 1、循环链表( Circular LinkedList)是另一种形式的链式存储结构。其特点是表中最后一个结点 的指针域指向头结点，整个链表形成一个环。 2、由此，从表中任一结点出发均可找到表中其他结点。 3、优点：从表中任意结点出发均可找到表中其他结点。 二、循环链表与单链表的区别 1、循环链表的操作和单链表基本一致。 2、差别仅在于：当遍历链表时，判别当前指针P是否指向表尾结点的终止条件不同。 3、由于循环链表中没有NULL指针，故涉及遍历操作时，其终止条件就不再像单链
数据结构-循环链表-C语言实现循环链表功能-数据结构学习
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 实现了以下功能： 创建无头循环链表 向循环链表中插入...
双链表-循环链表-静态链表.pdf
04-14
双链表、循环链表和静态链表是数据结构中的三种不同类型的链式存储结构。它们各自有其特点和适用场景，下面我们将详细介绍这三种链表及其基本操作。 首先，双链表是一种线性数据结构，它的每个节点包含两个指针，...
链表-使用C语言实现循环链表.zip
03-13
4. 遍历链表：由于是循环链表，遍历可以从任意节点开始，直到再次遇到起点。 此外，还应提供函数来检查链表是否为空，以及打印链表中的所有节点等辅助功能。为了实现这些操作，我们需要维护一个头节点指针，以便...
有头循环双向链表-链表
最新发布
09-11
链表 链表 链表 链表 链表
链表-使用C语言实现非循环双向链表-带头结点+尾结点.zip
03-13
本篇将详细介绍如何使用C语言来实现一个非循环双向链表，包括带头结点和尾结点的链表。 首先，让我们定义链表节点的数据结构。在非循环双向链表中，每个节点包含两个指针，分别指向它的前一个节点和后一个节点。...
循环链表
lzjsqn的专栏
10-30 923
循环链表循环链表 基本概念 设计与实现 代码实现 优缺点 约瑟夫问题-循环链表典型应用1.基本概念循环链表的定义： 　　将单链表中最后一个数据元素（也去节点）的next指针指向第一个元素 　　 循环链表拥有单链表的所有操作 创建链表 销毁链表 获取链表长度 清空链表 获取第pos个元素操作 插入元素到位置pos 删除位置pos处的元素 新增功能：游标的定
顺序表与链表（双向带头循环）的优缺点对比
qq_52454367的博客
04-19 590
顺序表优点： 1.按下标进行随机访问（比如二分查找，和方便一些排序） 顺序表缺点 1.空间不够需要增容（增容其实算是缺点，因为增容会一定程度上地消耗程序的性能），可能有一定的空间浪费 2.头部或者中间 插入/删除 数据，需要挪动数据，效率比较低->o(N) 链表优点 1.按需申请内存，需要存一个数据，就申请一块内存，不存在空间浪费 2.任意位置o（1）的时间复杂度内插入删除数据 链表缺点 1.不支持按下标随机访问 总结：两数据结构是相辅相成的，没有谁是完美的...
数据结构-线性表（四）循环链表
北以晨光的博客
09-15 1185
数据结构-线性表（四）循环链表 本文介绍了单循环链表和双循环链表以及它们的代码实现； 还详细对比了顺序表和链表以及如何选取。
Go语言学习笔记【10】 数据结构之单链表、双链表、循环链表
LC520730的博客
08-10 508
go实现单链表的头/尾部插入、删除，头尾元素的获取，判断元素是否包含，链表反转，循环链表及Josephus问题
【LeetCode刷题记录】单链表难点总结及Python代码实现
Yulki的博客
11-23 357
不时记录一下自己刷题的想法，以免后续遗忘，所有的代码都是用Python写的，因为日后需要，尽量所有代码都用Python写了，单链表的应该没有特别大的难度的东西了，有几道题写了测试的代码，应该都能看出来哈，没有加图解，对找环不清楚的，可以去看看知乎。
【数据结构-C语言】单向链表，循环单向链表
sakura0908的博客
03-02 2508
顺序表：顺序存储的线性表 链式表：链式存储的线性表，简称链表 由于顺序表的缺点（数据连续存储），顺序存储的数据因为挤在一起而导致需要成片移动，那很容易想到的解决方案是将数据离散地存储在不同内存块中，然后再用指针将他们串起来，这种朴素的思路所形成的链式线性表，就是所谓的链表。顺序表和链表存在的基本样态如下图所示
循环链表和双向链表浅析
qq_42108074的博客
01-28 563
循环链表和双向链表浅析
循环链表的作用
qq_42092076的博客
07-26 4572
作用是循环链表是无须增加存储量，仅对表的链接方式稍作改变，即可使得表处理更加方便灵活。 ①循环链表中没有NULL指针。涉及遍历操作时，其终止条件就不再是像非循环链表那样判别p或p-＞next是否为空，而是判别它们是否等于某一指定指针，如头指针或尾指针等。 ②在单链表中，从一已知结点出发，只能访问到该结点及其后续结点，无法找到该结点之前的其它结点。而在单循环链表中，从任一结点出发都可访问到表中所...
数据结构-双向循环链表
10-23
双向循环链表是一种链式存储结构，它的每个节点都有两个指针，一个指向前驱节点，一个指向后继节点。与单向链表不同的是，双向循环链表的尾节点的后继节点指向头节点，头节点的前驱节点指向尾节点，形成一个环形结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值