C语言-线性表链式存储（循环链表）

最新推荐文章于 2023-11-26 17:14:53 发布
最新推荐文章于 2023-11-26 17:14:53 发布
阅读量300 收藏 3
点赞数 1
分类专栏： C/C++数据结构和算法 文章标签： c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_34791632/article/details/105248992
版权

理解循环链表

单链表和循环链表的区别在于，尾部结点的后继指针是否指向头部结点。相对于其他功能基本相似。

循环链表的插入分析

普通插入：例如pos = 2，和单链表是一样的

                              

尾插法：辅助指针向后跳lenght次，指向链表最后元素，单链表支持尾插法

                              

头插法：插入第一个元素时，当链表中有其他元素时插入头部时

插入第一个元素时

pos = 0, 提供辅助指针current,当前辅助指针current指向头部结点。

首先判断current指针是否指向头部结点，其次通过Get方法获取到链表的最后一个结点（Null），最后让最后一个结点的后继指针指向插入的结点。

                              

当链表中有其他元素时插入头部时

                              

插入结点的异常处理：

  • 如果是插入第一个结点需要特别注意

循环链表的删除分析

普通删除：假设删除pos = 3/pos = length

pos = 3 

                              

pos = length 

                              

删除头部结点：

 

                              

删除结点的异常处理：

  • 如果删除头部结点
  • 如果没有任何结点
//CircleLinkList.h
#pragma once
typedef void CircleLinkList;
//链表结点（包含了后继结点指针域）
typedef struct tag_CircleLinkListNode
{
	struct tag_CircleLinkListNode *next;
}TCircleLinkListNode;

//创建循环链表
CircleLinkList *CircleLinkList_Creat();
//销毁链表
void CircleLinkList_Destroy(CircleLinkList*list);
//清空链表
void CircleLinkList_Clear(CircleLinkList *list);
//获取链表长度
int CircleLinkList_GetLength(CircleLinkList *list);
//在指定位置插入结点
int CircleLinkList_inster(CircleLinkList *list, TCircleLinkListNode *node, int pos);
//获取指定位置的结点
TCircleLinkListNode *CircleLinkList_Get(CircleLinkList *list, int pos);
//删除指定位置的结点
TCircleLinkListNode *CircleLinkList_Delete(CircleLinkList *list, int pos);

//CircleLinkList.c
#pragma warning(disable : 4996)
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "CircleLinkList.h"

//循环链表结构
typedef struct tag_CircleLinkList
{
    TCircleLinkListNode header;//头部结点
    TCircleLinkListNode *slider;//游标
    int length;//链表长度
}TCircleLinkList;

//创建循环链表
CircleLinkList * CircleLinkList_Creat()
{
    TCircleLinkList *list = NULL;
    list = (TCircleLinkList *)malloc(sizeof(TCircleLinkList));//给链表分配堆内存
    if (list == NULL)
    {
        printf("LinkList_Creat err: list = NULL");
        return NULL;
    }
    memset(list, 0, sizeof(TCircleLinkList));//初始化堆内存
    list->length = 0;
    list->header.next = NULL;
    list->slider = NULL;
    return list;
}
//销毁链表
void CircleLinkList_Destroy(CircleLinkList * list)
{
    if (list == NULL)
    {
        printf("LinkList_Destroy err: list = NULL");
        return;
    }
    free(list);//释放堆内存空间
    printf("LinkList_Destroy finished \n");
    return;
}
//清空循环链表
void CircleLinkList_Clear(CircleLinkList * list)
{
    TCircleLinkList *temp = NULL;
    if (list == NULL)
    {
        printf("LinkList_Clear err: list = NULL");
        return;
    }
    temp = (TCircleLinkList *)list;//类型转换
    temp->length = 0;
    temp->header.next = NULL;
    temp->slider = NULL;
    return;
}
//获取链表长度
int CircleLinkList_GetLength(CircleLinkList * list)
{
    TCircleLinkList *temp = NULL;
    if (list == NULL)
    {
        printf("LinkList_GetLength err: list = NULL");
        return -1;
    }
    temp = (TCircleLinkList *)list;//类型转换
    return temp->length;//返回链表长度
}
//在指定位置插入结点
int CircleLinkList_inster(CircleLinkList * list, TCircleLinkListNode * node, int pos)
{
    TCircleLinkList *temp = NULL;
    int i = 0;
    if (list == NULL || node == NULL || pos < 0)
    {
        printf("LinkList_inster err: list = NULL || node = NULL || pos < 0");
        return -1;
    }
    temp = (TCircleLinkList *)list;//类型转换
    TCircleLinkListNode * current = &(temp->header);//辅助指针，指向头部结点
    for (i = 0; i < pos && node->next != NULL; i++)//通过遍历跳转指向要插入位置的前一个结点处
    {
        current = current->next;
    }
    node->next = current->next;//让插入结点的后继指针指向current的后继结点
    current->next = node;//让current的后继指针指向插入的结点

    if (temp->length == 0)//初始化游标指向
    {
        temp->slider = node;//指向链表的第一个结点处
    }
    temp->length++;//长度+1
    //头插法（异常处理）
    if (current == &temp->header)//如果插入第一个结点时判断当前辅助指针current是否指向头部结点
    {
        TCircleLinkListNode *last = CircleLinkList_Get(temp, temp->length - 1);//获取链表的尾部结点
        last->next = current->next;//让尾部结点的后继指针指向辅助指针current的后继结点处，完成循环链表指向
    }
    return 0;
}
//获取指定位置的结点
TCircleLinkListNode * CircleLinkList_Get(CircleLinkList * list, int pos)
{
    TCircleLinkList *temp = NULL;
    int i = 0;
    if (list == NULL  || pos < 0)
    {
        printf("LinkList_Get err: list = NULL ||  pos < 0");
        return NULL;
    }
    temp = (TCircleLinkList *)list;//类型转换
    TCircleLinkListNode * current = &(temp->header);//提供辅助指针，并指向头部结点
    for (i = 0; i < pos ; i++)
    {
        current = current->next;
    }
    return current->next;//返回指定位置的结点
}
//删除指定位置的结点
TCircleLinkListNode * CircleLinkList_Delete(CircleLinkList * list, int pos)
{
    TCircleLinkList *temp = NULL;
    int i = 0;
    if (list == NULL || pos < 0)
    {
        printf("LinkList_Get err: list = NULL ||  pos < 0");
        return NULL;
    }
    temp = (TCircleLinkList *)list;//类型转换
    TCircleLinkListNode *current = &(temp->header);//提供辅助指针current指向头部结点
    TCircleLinkListNode *ret = NULL;//提供辅助指针用来存放临时结点
    TCircleLinkListNode *last = NULL;//提供辅助指针用来存放尾部结点
    for (i = 0; i < pos; i++)
    {
        current = current->next;
    }
    if (current == &(temp->header))//判断辅助指针current是否指向头部结点
    {
        //获取到尾部结点
        last = CircleLinkList_Get(list, CircleLinkList_GetLength(list) - 1);
    }
    ret = current->next;//辅助指针ret临时存放要删除的结点
    current->next = ret->next;//让当前current的后继指针指向要删除的结点的后继节点处，完成删除
    temp->length--;//链表长度-1
    //如果删除头部结点
    if (last != NULL)
    {
        //让头结点的后继指针指向要删除的的后继结点
        temp->header.next = ret->next;
        //让尾部结点的后继指针指向要删除结点的后继结点处
        last->next = ret->next;
    }
    //如果删除的结点正好是游标所指处
    if (temp->slider == ret)
    {
        //游标下移
        temp->slider = ret->next;
    }
    //删除结点后链表长度为0
    if (temp->length == 0)
    {
        temp->header.next = NULL;
        temp->slider = NULL;
    }
    return ret;//返回被删除的结点
}
//重置游标
TCircleLinkListNode * CircleLinkList_Reset(CircleLinkList * list)
{
    if (list == NULL)
    {
        printf("LinkList_Reset err: list = NULL");
        return NULL;
    }
    TCircleLinkList *temp = (TCircleLinkList *)list;//类型转换
    temp->slider = temp->header.next;//让游标指向第一个结点处
    return temp->slider;//返回游标
}
//获取游标当前指向的结点
TCircleLinkListNode * CircleLinkList_Current(CircleLinkList * list)
{
    if (list == NULL)
    {
        printf("LinkList_Current err: list = NULL");
        return NULL;
    }
    TCircleLinkList *temp = (TCircleLinkList *)list;//类型转换
    return temp->slider;//返回当前游标
}
//把当前位置返回，并且游标下移
TCircleLinkListNode * CircleLinkList_Next(CircleLinkList * list)
{
    if (list == NULL)
    {
        printf("linkList_Next err: list = NULL");
        return NULL;
    }
    TCircleLinkList *temp = (TCircleLinkList *)list;//类型转换
    if (temp->slider == NULL)
    {
        printf("linkList_Next err: temp->slider = NULL");
        return NULL;
    }
    TCircleLinkListNode *current = temp->slider;//提供辅助指针current指向当前游标的位置
    temp->slider = current->next;//游标下移
    return current;
}
//删除指定结点
TCircleLinkListNode * CircleLinkList_DeleteNode(CircleLinkList * list, TCircleLinkListNode * node)
{
    if (list == NULL || node == NULL)
    {
        printf("LinkList_DeleteNode err: list = NULL || node = NULL");
        return NULL;
    }
    int i = 0;
    TCircleLinkList *temp = (TCircleLinkList *)list;//类型转换
    TCircleLinkListNode *current = &temp->header;//提供辅助指针current指向头部结点
    TCircleLinkListNode *ret = NULL;//提供辅助指针ret存放临时结点
    for (i = 0; i < temp->length; i++)//通过遍历跳转
    {
        if (current->next == node)//如果辅助指针current的后继指针等于指定删除的结点
        {
            ret = current->next;//存放要被删除的结点
            break;
        }
        current = current->next;
    }
    //结点不为空时，作删除操作
    if (ret != NULL)
    {
        CircleLinkList_Delete(temp, i);
    }
    return ret;//返回被删除的结点
}
//测试代码
#pragma warning(disable : 4996)
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "CircleLinkList.h"

typedef struct tag_Teacher    
{
    TCircleLinkListNode node;
    int age;
    char *name;
}Teacher;

int main(int argc, char** argv)
{
    Teacher t1, t2, t3, t4, t5;
    t1.age = 20;
    t1.name = "zhangsan";
    t2.age = 21;
    t2.name = "lisi";
    t3.age = 22;
    t3.name = "wangwu";
    t4.age = 23;
    t4.name = "zhaoliu";
    t5.age = 24;
    t5.name = "wangqi";

    CircleLinkList *list = NULL;
    list = CircleLinkList_Creat();
    if (list == NULL)
    {
        printf("LinkList_Creat err: list = NULL");
        return -1;
    }
    int i, ret = 0;

    ret = CircleLinkList_inster(list, (TCircleLinkListNode *)&t1, CircleLinkList_GetLength(list));
    ret = CircleLinkList_inster(list, (TCircleLinkListNode *)&t2, CircleLinkList_GetLength(list));
    ret = CircleLinkList_inster(list, (TCircleLinkListNode *)&t3, CircleLinkList_GetLength(list));
    ret = CircleLinkList_inster(list, (TCircleLinkListNode *)&t4, CircleLinkList_GetLength(list));
    ret = CircleLinkList_inster(list, (TCircleLinkListNode *)&t5, CircleLinkList_GetLength(list));

    printf("LinkList length = %d\n", CircleLinkList_GetLength(list));

    for (i = 0; i < CircleLinkList_GetLength(list); i++)
    {
        Teacher *t = (Teacher *)CircleLinkList_Get(list, i);
        printf("age = %d,name = %s\n", t->age, t->name);
    }

    system("pause");
    return 0;
}

游标功能

通过在循环链表中增加游标功能可以方便解决约瑟夫问题

1-8围成一圈，从1开始报数报道3的人出列，然后再从下一个人开始从1报数，依次类推，求出出列顺序。

//在CircleLinkList.h中添加一下方法
//重置游标，指向链表的第一个结点处
TCircleLinkListNode *CircleLinkList_Reset(CircleLinkList *list);
//获取当前游标所指的结点
TCircleLinkListNode *CircleLinkList_Current(CircleLinkList *list);
//返回当前游标指向的结点，并游标下移
TCircleLinkListNode *CircleLinkList_Next(CircleLinkList *list);
//删除指定结点
TCircleLinkListNode *CircleLinkList_DeleteNode(CircleLinkList *list, TCircleLinkListNode *node);
#pragma warning(disable : 4996)
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "LinkList.h"

typedef struct MyValue
{
    TLinkListNode node;
    int val;
}TValue;

int main(int argc, char** argv)
{
    TValue v1, v2, v3, v4, v5, v6, v7, v8;
    v1.val = 1;
    v2.val = 2;
    v3.val = 3;
    v4.val = 4;
    v5.val = 5;
    v6.val = 6;
    v7.val = 7;
    v8.val = 8;

    LinkList *list = (LinkList *)LinkList_Creat();
    if (list == NULL)
    {
        printf("LinkList_Creat err: list = NULL");
        return -1;
    }
    int i, ret = 0;
    LinkList_inster(list, (TLinkListNode *)&v1, LinkList_GetLength(list));
    LinkList_inster(list, (TLinkListNode *)&v2, LinkList_GetLength(list));
    LinkList_inster(list, (TLinkListNode *)&v3, LinkList_GetLength(list));
    LinkList_inster(list, (TLinkListNode *)&v4, LinkList_GetLength(list));
    LinkList_inster(list, (TLinkListNode *)&v5, LinkList_GetLength(list));
    LinkList_inster(list, (TLinkListNode *)&v6, LinkList_GetLength(list));
    LinkList_inster(list, (TLinkListNode *)&v7, LinkList_GetLength(list));
    LinkList_inster(list, (TLinkListNode *)&v8, LinkList_GetLength(list));

    for ( i = 0; i < LinkList_GetLength(list); i++)
    {
        TValue *val = (TValue *)linkList_Next(list);
        printf("TValue val[%d] = %d\n", i + 1, val->val);
    }
    printf("约瑟夫问题求解\n");
    LinkList_Reset(list);
    while (LinkList_GetLength(list) > 0)
    {
        TValue *val = NULL;
        for (int i = 1; i < 3; i++)
        {
            linkList_Next(list);
        }
        val = LinkList_Current(list);
        printf("TValue val = %d\n", val->val);
        LinkList_DeleteNode(list, (TLinkListNode *)val);
    }

    LinkList_Destroy(list);
	
    system("pause");
    return 0;
}

 

代码黑洞_
关注
专栏目录
c语言数据结构（二）----线性表链式存储结构及运算实现（单链表篇）
qq_45704650的博客
02-21 632
上回我们学习了用数组构造顺序表，今天我们学习用指针构造链表。 链表分为单链表
线性表链式存储--链表
10-09
在提供的压缩包文件"线性表链式存储"中，很可能包含了实现链表操作的C语言代码，如初始化链表、插入节点、删除节点、遍历链表等函数。 链表有多种变体，如单链表、双链表、循环链表等。单链表只包含一个指针域，而...
线性表的链式存储代码--C语言版
02-22
1.C 语言实现的线性表的链式存储功能 2.包含测试用例代码
C语言-线性表链式存储（单链表）
代码黑洞
04-01 370
理解链式存储 为了表示数据元素与直接后继数据元素的关系，每个数据元素除了保存自己的信息之外，还需要存储直接后继的信息。 那么我们应该怎么做呢？首先我们应该在每个数据结点中包含一个指针域（存储直接后继结点的头部地址）。 头部结点：链表中的第一个结点，包含指向第一个数据元素的指针以及链表自身的一些信息 数据结点：链表中的数组元素结点，包含...
单链表（线性表的链式存储）---C语言版
weixin_47138646的博客
12-07 2741
单链表（线性表的链式存储）—C语言版 一、相关说明 逻辑上相邻的元素在物理位置上不一定相邻。 优点： 没有了顺序存储所具有的弱点（也就是说：插入和删除不需要移动元素，而只需要修改指针。） 同时，由于不借助数组实现，在定义链表时，无需指定它的长度。 缺点： 也失去了顺序存储的优点 非随机存取（不能直接找到某个特定序号的结点，需要从表头开始遍历） 存储密度降低（除了存储本身信息外链表还要存储指针） 二、单链表的定义 定义 线性表的链式存储又称为单链表，它是指通过一组任意的存储单位来存储线性表中的元
【C语言之线性表链式存储结构】
qq_39842609的博客
03-24 2893
C语言之线性表链式存储结构
C语言线性表的链式存储（详解）
qq_45973003的博客
11-26 803
3：链表是由一系列的节点组成，每个节点包含两个域，一个是数据域，一个是指针域。链表是由一系列的节点组成，每个节点包含两个域，一个是数据域，一个是指针域。1：插入新元素，空间不足申请更大的内存空间。1：线性表的顺序存储：用一块连续的内存空间。线性表的顺序存储：用一块连续的内存空间。2：线性表的链式存储：不连续的内存空间。2：数据结构是算法需要处理问题的载体。《如果最高次项的乘数不是1，就舍去》线性表的链式存储：不连续的内存空间。2：旧的空间的数据拷贝到新的空间。1：算法是为了解决问题二设计的。
基于C语言的线性表链式存储算法.pdf
09-19
涂玉芬副教授在论文中提出了基于C语言实现线性表链式存储的两种方法，尾插法和头插法，并对链式存储的算法和C语言实现进行了详细的阐述。这些内容对于数据结构的教学和应用都具有重要的参考价值，尤其是在需要频繁...
C语言实现线性表链式存储的输出算法
在C语言中，单链表是一种线性表的链式存储实现方式。给定的代码段展示了如何输出单链表中的所有数据。函数`DispTable`接收一个类型为`HList`的指针，该指针通常指向链表的头节点。在函数内部，`DList *p=h->next`将`...
c语言线性表链式存储
最新发布
04-01
以下是C语言中线性表链式存储的一般实现方式： ```c // 定义链表节点结构 typedef struct Node { int data; // 数据域 struct Node* next; // 指针域，指向下一个节点 } Node; // 初始化链表 void initList(Node...
C语言基于链式存储的线性表
06-17
C语言编写基于链式存储的线性表（链表） 含以下基本操作： 1.初始化、删除、清空链表 2.判断是否为空、返回长度 3.插入、删除 4.输出链表 5.寻找前一个节点、后一个节点 6.排序
线性表的链式存储结构（C语言实现）
qq_32262155的博客
10-29 2623
由于线性表的顺序存储结构在进行插入与删除是要移动大量的元素，会耗费大量的时间，线性表的链式存储结构就完美的解决了这个问题。 首先是单链表的创建，有头插法和尾插法。 头插法： /* 随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */ void CreateListHead(LinkList *L, int n) { LinkList p; int i;
c语言数据结构 - 线性表的链式存储
fengxuewei123的博客
04-03 189
概述 NULL code #include "LinkList.h" // 自定义数据类型 typedef struct PERSON{ char name[64]; int age; int score; }Person; // test 函数 void test02(); void test03(); void test04(); // 用户自定义 打印函数 void myPrint(void*); int main(int argc, char **argv){
数据结构严薇敏——线性表的链式存储（C语言）
Attention_0的博客
07-25 822
线性表的链式存储结构特点使用一组任意的存储单元存储线性表的数据元素（这组存储单元地址可以是连续的，也可以是不连续的）。因此，为了表示每个数据元素与其前后的数据元素的逻辑关系，除了需要存储本身的数据信息之外，还需要存储一个指针来指向当前位置的下一个数据元素的位置。于是需要定义一个数据类型，里面包含两个域，数据域和指针域，我们称之为结点。 其数据类型（结点）定义方式如下： typedef str...
C语言线性表之循环单链表
RToax
12-05 459
#include #include int typeOfLinkList; typedef struct LNode{ int data; struct LNode *next; }LNode, *LoopLinkList; /* 基本算法（遍历） */ void show(LNode *L, int n) { int in = 0; printf(" S
线性表的链式存储C语言版
岳麓丹枫
06-22 421
#include #include #define N 10 typedef struct Node { int data; struct Node *next; }Node, *LinkedList; void initList(LinkedList *L); int ListInsert(LinkedList *L, int index, int e); int ListDe
（C语言）线性表的链式存储的实现
vipchen1997的博客
06-18 1251
//带头结点单链表的实现 #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; typedef struct LinkListNode { int data; struct LinkListNode *next; }Node,*pNode; pNode Create(void); //初始化，创建头结点 int Isempty(pNode...
线性表的链式存储C语言实现
weixin_33834628的博客
04-04 131
花费了一个下午的时间才成功运行这些代码，因为指针的bug。看来对指针还是需要进一步深入学习。下面是代码：困扰的是改成create_list（link_list list, int n）就会有段错误。//main.c #include<stdio.h> #include<stdlib.h> #define OK 0 #define ERROR -1...
C语言实现一般线性表的链式存储
linuxlsl的博客
10-22 433
C语言实现一般线性表的顺序存储,以下是在VS2013编译通过的，欢迎讨论。有关数据结构的概念可看我的另一篇文章http://blog.csdn.net/linuxlsl/article/details/45649655 一、头文件linklist.h #ifndef _LINKLIST_H_ #define _LINKLIST_H_ typedef void LinkList; typed
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值