第8节 循环链表

最新推荐文章于 2023-12-27 14:53:05 发布
最新推荐文章于 2023-12-27 14:53:05 发布
阅读量107 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pt_raspi_fresher/article/details/87118705
版权

-------------------------------------资源来源于网络,仅供自学使用,如有侵权,联系我必删.

第一:

单链表的局限:

  单链表可以用于表示任意的线性关系

 有些线性关系是循环的 ， 即没有队尾元素

 

单链表的改进

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

 

第二:

循环链表的操作

?  循环链表拥有单链表的所有操作
    创建链表
    销毁链表
    获取链表长度
    清空链表
    获取第pos 个元素操作
    插入元素到位置pos
    删除位置pos 处的元素

 

第三:

循环链表的操作

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

?  循环链表的新操作
?  获取当前游标指向的数据元素
?  将游标重置指向链表中的第一个数据元素
?  将游标移动指向到链表中的下一个数据元素
? 直接指定删除链表中的某个数据元素

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

CircleListNode* CircleList_Next(CircleList* list);

 

第四

循环链表的新操作

#ifndef _CIRCLELIST_H_
#define _CIRCLELIST_H_

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

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

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 <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 )
    {
        ret->length = 0;
        ret->header.next = NULL;
        ret->slider = NULL;
    }
    
    return ret;
}

void CircleList_Destroy(CircleList* list) // O(1)
{
    free(list);
}

void CircleList_Clear(CircleList* list) // O(1)
{
    TCircleList* sList = (TCircleList*)list;
    
    if( sList != NULL )
    {
        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( sList != NULL )
    {
        ret = sList->length;
    }
    
    return ret;
}

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos) // O(n)
{ 
    TCircleList* sList = (TCircleList*)list;
    int ret = (sList != NULL) && (pos >= 0) && (node != NULL);
    int i = 0;
    
    if( ret )
    {
        CircleListNode* current = (CircleListNode*)sList;
        
        for(i=0; (i<pos) && (current->next != NULL); i++)
        {
            current = current->next;
        }
        
        node->next = current->next;
        current->next = node;
        
        if( sList->length == 0 )
        {
            sList->slider = node;
            node->next = node;
        }
        
        sList->length++;
    }
    
    return ret;
}

CircleListNode* CircleList_Get(CircleList* list, int pos) // O(n)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    int i = 0;
    
    if( (sList != NULL) && (pos >= 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) )
    {
        CircleListNode* current = (CircleListNode*)sList;
        CircleListNode* first = sList->header.next;
        CircleListNode* last = (CircleListNode*)CircleList_Get(sList, sList->length - 1);
        
        for(i=0; i<pos; i++)
        {
            current = current->next;
        }
        
        ret = current->next;
        current->next = ret->next;
        
        sList->length--;
        
        if( first == ret )
        {
            sList->header.next = ret->next;
            last->next = ret->next;
        }
        
        if( sList->slider == ret )
        {
            sList->slider = ret->next;
        }
        
        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;
        
        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) // 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 <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 )
    {
        ret->length = 0;
        ret->header.next = NULL;
        ret->slider = NULL;
    }
    
    return ret;
}

void CircleList_Destroy(CircleList* list) // O(1)
{
    free(list);
}

void CircleList_Clear(CircleList* list) // O(1)
{
    TCircleList* sList = (TCircleList*)list;
    
    if( sList != NULL )
    {
        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( sList != NULL )
    {
        ret = sList->length;
    }
    
    return ret;
}

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos) // O(n)
{ 
    TCircleList* sList = (TCircleList*)list;
    int ret = (sList != NULL) && (pos >= 0) && (node != NULL);
    int i = 0;
    
    if( ret )
    {
        CircleListNode* current = (CircleListNode*)sList;
        
        for(i=0; (i<pos) && (current->next != NULL); i++)
        {
            current = current->next;
        }
        
        node->next = current->next;
        current->next = node;
        
        if( sList->length == 0 )
        {
            sList->slider = node;
            node->next = node;
        }
        
        sList->length++;
    }
    
    return ret;
}

CircleListNode* CircleList_Get(CircleList* list, int pos) // O(n)
{
    TCircleList* sList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    int i = 0;
    
    if( (sList != NULL) && (pos >= 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) )
    {
        CircleListNode* current = (CircleListNode*)sList;
        CircleListNode* first = sList->header.next;
        CircleListNode* last = (CircleListNode*)CircleList_Get(sList, sList->length - 1);
        
        for(i=0; i<pos; i++)
        {
            current = current->next;
        }
        
        ret = current->next;
        current->next = ret->next;
        
        sList->length--;
        
        if( first == ret )
        {
            sList->header.next = ret->next;
            last->next = ret->next;
        }
        
        if( sList->slider == ret )
        {
            sList->slider = ret->next;
        }
        
        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;
        
        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) // 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"

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

struct Value
{
    CircleListNode header;
    int v;
};

int main(int argc, char *argv[])
{
    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);
    
	return 0;
}

小结

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

嵌入式开发学习者
关注
专栏目录
数据结构（超详细讲解！！）第三节 循环链表
2201_76115387的博客
10-07 633
循环链表
c++实现的循环链表
04-09
使用c++实现的循环链表程序，供大家学习数据结构参考使用
循环链表
qwe954443563的博客
12-02 201
循环链表 1.循环单链表与单链表的区别： 单链表：从一个结点出发只能找到后续的各个结点 循环单链表：从一个结点出发可以找到其他任何一个结点。 2.循环单链表的初始化： //初始化循环单链表 bool InitList(LinkList &L) { L = new(Node); if (L == NULL) return false; L->next = L; return true; } 3.判断循环单链表是否为空 //判断循环单链表是否为空 bool Empty(LinkLis
JS实现单链表、单循环链表
11-02 95
链表 　　链表是一种物理存储单元上非线性、非连续性的数据结构（它在数据逻辑上是线性的），它的每个节点由两个域组成：数据域和指针域。数据域中存储实际数据，指针域则存储着指针信息，指向链表中的下一个元素或者上一个元素。正是由于指针的存在，链表的存储在物理单元是非连续性的。 链表的优点和缺点同样明显。和线性表相比，链表在添加和删除节点上的效率更高，因为其只需要修改指针信息...
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3222
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
C语言实现循环链表
最新发布
m0_50502677的博客
12-27 1061
循环链表是一种特殊形式的链表结构，其特点是将单链表的终端节点的指针端由空指针改为指向头节点，形成一个环形结构。循环链表的尾指针指向终端节点，而尾指针指向的下一个节点即为头节点。带头节点的循环链表包含一个额外的头节点，该头节点不存储实际数据。数据从头节点的下一个节点开始存储，尾指针指向终端节点，使整个链表形成一个环。不带头结点的循环链表直接从第一个节点开始存储数据，尾指针指向终端节点，形成一个闭合的环。尾指针指向的节点即为终端节点，可存放数据。
循环链表详解（C语言）
m0_55698213的博客
10-14 2177
本文主要讲述循环链表的基本定义特点以及一些常见操作并使用C语言代码对其进行实现。如何使用C语言代码去创建循环链表、插入头为节点、删除元素、输出链表长句、打印链表等基本运算。本文仅仅主要介绍了循环链表的概念、特点、运算以及循环链表的优缺点比较。特别注意当我们在实现循环连表时， 循环单链表没有明显的结束条件，很容易陷入死循环。此时，我们可以设置一个标记点作为循环的标记，当我们知道表长，我们也可以设置一个计数器来结束循环。
数据结构（六）——循环链表
热门推荐
天山老妖
03-03 1万+
一、循序链表简介 1、循环链表的定义 循环链表的任意元素都有一个前驱和一个后继，所有数据元素在关系上构成逻辑上的环。 循环链表是一种特殊的单链表，尾结点的指针指向首结点的地址。 循环链表的逻辑关系图如下： 2、循环链表的设计实现 循环链表的设计实现要点： A、通过模板定义CircleList，继承自LinkedList B、定义连接链表首尾的内部函数 C、实现首元素的插入和删除操作 D、重写清空操作和遍历操作 3、循环链表的实现关键 A、插入位置为0时，头结点和尾结点均指向.
单向循环链表改成双向循环链表
weixin_46034571的博客
11-28 691
【代码】单向循环链表改成双向循环链表。
深入解析C++的循环链表与双向链表设计的API实现
09-02
循环链表是单链表的一种变体，它的最后一个节点指向链表的第一个节点，形成了一个逻辑上的环。双向链表则在每个节点中包含两个指针，分别指向其前一个和后一个节点，使得双向操作更为便捷。 循环链表的API设计通常...
求循环节·链表
zhj12399的博客
10-20 2253
求循环节 题目信息 对于任意的真分数 N/M （ 0 < N < M ），均可以求出对应的小数。如果采用链表存储各位小数，对于循环节采用循环链表表示，则所有分数均可以表示为如下链表形式 输入： N M 输出： 整个循环节 要求：编写一个尽可能高效的查找循环节起始点的函数： NODE * find( NODE * head, int * n )。函数的返回值为循环节的起点（即图中的指针p），n为循环节的长度。请同时提交将分数转换为小数的函数 change( int n, int m, NODE
数据结构（超详细讲解！！）第三节 循环链表(尾指针）
2201_76115387的博客
10-10 477
循环链表用尾指针操作
第2节 判断程序的质量
一名从事物联网开发者的博客
08-19 416
-------------------------------------资源来源于网络,仅供自学使用,如有侵权,联系我必删. 第一: 算法效率的度量 ? 事前分析估算 依据统计的方法对算法效率进行估算 ? 影响算法效率的主要因素 算法采用的策略和方法 问题的输入规模 编译器所产生的代码 计算机执行速度 第二: 算法效率的简单...
第12节 栈的应用实战一
一名从事物联网开发者的博客
02-13 367
-------------------------------------资源来源于网络,仅供自学使用,如有侵权,联系我必删. 第一: ?  在C 语言中有一些符号是成对匹配出现的 括号:     ()      []      {}    &lt;&gt; 引号:    ''    ""   解决方案 ?  算法思路 ?  从第一个字符开始扫描 ?  当遇见普通字符时忽略 ， 当遇...
第13节 栈的应用实战二
一名从事物联网开发者的博客
02-13 329
-------------------------------------资源来源于网络,仅供自学使用,如有侵权,联系我必删. 第一:     中缀表达式符合人类的阅读和思维习惯     后缀表达式符合计算机的 “ 运算习惯”     中缀表达式                 后缀表达式      5 + 3                    =&gt;     5 3 +     ...
第36节 查找的概念
一名从事物联网开发者的博客
02-20 235
-------------------------------------资源来源于网络,仅供自学使用,如有侵权,联系我必删. 第一: 查找的概念 ?  查找的定义 ?  查找表是由同一类型的数据元素构成的集合 ?  查找是根据给定的某个值 ， 在查找表中确定一个其关键字等于给定值的数据元素   ?   查找的操作 ?  静态查找    •  查询 某个 特定的 数据元素是否在查找表中 ...
第30节 霍夫曼树
一名从事物联网开发者的博客
02-17 228
-------------------------------------资源来源于网络,仅供自学使用,如有侵权,联系我必删. 第一: 霍夫曼树   第二: 霍夫曼树的应用   第三: 构建霍夫曼树 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;malloc.h&gt; #include ...
循环链表操作实战：从基础到高级
1. 初始化单循环链表：这是创建循环链表的第一步，需要确保链表的第一个节点的next指针指向最后一个节点，形成一个闭合环。 2. 创建单循环链表：从头结点开始，依次添加元素并调整指针，使得最后一个节点的next指向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值