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

最新推荐文章于 2023-09-03 17:57:43 发布
最新推荐文章于 2023-09-03 17:57:43 发布
阅读量1k 收藏 3
点赞数 1
分类专栏： 数据结构 c语言 文章标签： 链表 c语言 数据结构 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47138646/article/details/121775485
版权

目录

循环链表

特点：表中最后一个结点的指针域指向头结点，整个链表形成一个环。
既然是环的话，那就不难想象，从表中任意一个结点出发都可以找到表中其他结点。
在这里插入图片描述

一、循环单链表

仍旧使用该例子，我们要如何存储用循环单链表实现它呢？

idnamedescription
1史强最强辅助
2章北海我不需要钢印，我是自己思想的主人
3罗辑人类不感谢罗辑
4维德失去人性，失去很多。失去兽性，失去一切

循环单链表与单链表唯一的区别就是多了一个由尾结点指向头结点的指针。
所以循环链表的操作与单链表基本一致
唯一的差别就是循环的条件不是p或p->next是否为空，而是它们是否等于头指针(p==L或p->next==L)。

循环单链表示例图(含头结点)：
在这里插入图片描述
循环单链表逻辑图(含头结点)：
在这里插入图片描述

1、循环单链表定义

步骤一：声明数据元素类型

typedef struct{
    int id;//对应表中的id
    char name[100];//对应表中的姓名
    char description[200];//对应表中的描述
}ElemType;//此处的ElemType是个类型名

步骤二：声明结点

typedef struct CNode{
    ElemType data;//数据域
    struct CNode *next;//指针域
}CNode,*CLinkList;
2、循环单链表操作

与单链表相比，循环单链表有两处操作与单链表不同。
一是：尾结点的指针域指向头结点
二是：遍历时，条件变成了p->next是否为头指针
这里只详细展示两个具体操作

初始化表。构造一个空表。
/*初始化*/
int InitList_CLink(CLinkList *L){
    *L=(CLinkList)malloc(sizeof(CNode));//创建头结点，并让头指针指向头结点
    if (!(*L)) return FALSE;//分配失败
    (*L)->next=(*L);//初始化为头指针
    return TRUE;//初始化成功
}

空表逻辑图:
在这里插入图片描述

求表长
/*求表长*/
int Length_CLink(CLinkList L){
    int i=0;//空表返回0
    CNode *s=L;
    while (s->next!=L){//遍历，直到尾结点，空表不进入循环
        s=s->next;//向后移动一个
        i++;//表长加一
    }
    return i;//返回表长
}
3、含尾指针的循环单链表

有时候在循环单链表中设立尾指针而不设头指针，可以时有些操作简化。
比如合并两个循环单链表时

在这里插入图片描述

二、循环双链表

循环双链表的逻辑图(含头结点)：
在这里插入图片描述

1、循环双链表定义

步骤一：声明数据元素类型

typedef struct{
    int id;//对应表中的id
    char name[100];//对应表中的姓名
    char description[200];//对应表中的描述
}ElemType;//此处的ElemType是个类型名

步骤二：声明结点

typedef struct CDNode{
    ElemType data;//数据域
    struct CDNode *prior;//指针域，指向前驱结点
    struct CDNode *next;//指针域，指向后继结点
}CDNode,*CDLinkList;
2、循环双链表操作

循环双链表与循环单链表唯一的区别就是多了一个指向前驱的指针。
所以循环双链表的操作与循环单链表也基本一致
就是对结点操作时，需要多操作一步，让p->prior指向前驱结点。
这里展示相对于循环单链表有变化的操作。

初始化表。构造一个空表。
/*初始化*/
int InitList_CLink(CDLinkList *L){
    *L=(CDLinkList)malloc(sizeof(CDNode));//创建头结点，并让头指针指向头结点
    if (!(*L)) return FALSE;//分配失败
    (*L)->prior=(*L);//初始化为头指针
    (*L)->next=(*L);//初始化为头指针
    return TRUE;//初始化成功
}

空表逻辑图：
在这里插入图片描述

根据数组创建双链表

1.头插法

/*头插法创建循环双链表*/
int create_HeadInsert(CDLinkList *L,ElemType a[],int n){
 // InitList_CLink(L);
    CDNode *s;//用来指示新创建的结点
    int i;
    for(i=n-1;i>=0;i--){//由于头插法是倒序插入，所以这里我们从数组最后开始遍历
        s=(CDLinkList)malloc(sizeof(CDNode));//创建一个新结点
        s->data=a[i];//为结点赋值
        s->next=(*L)->next;//让该结点指向第一个结点
        (*L)->next->prior=s;//第一个结点的前驱指向该结点
        s->prior=(*L);//该节点的前驱指向头结点
        (*L)->next=s;//让头结点指向该结点
    }
}

2.尾插法

/*尾插法创建循环双链表*/
int create_TailInsert(CDLinkList *L,ElemType a[],int n){
 // InitList_CLink(L);
    CDNode *s,*r=(*L); //s用来指示新创建的结点，r用来移动以连接链表
    int i;
    for(i=0;i<n;i++){//遍历数组
        s=(CDLinkList)malloc(sizeof(CDNode));//创建一个新结点
        s->data=a[i];//为结点赋值
        r->next=s;//r始终指向链表的尾端，这里将新结点连接到r的后面
        s->prior=r;//该结点的前驱指向r
        r=s;//r移动到链表尾端
    }
    r->next=(*L);//结束时，最后一个结点的指针域赋值为头指针
}
插入操作。在表L中的第i个位置上插入指定元素e。
/*插入*/
int ListInsert_CDLink(CDLinkList *L,int i,ElemType e){
    int j=0;//空表序号为0
    CDNode *p=(*L);//p指向头结点
    CDNode *s;//s用来指示新创建的结点
    while (p->next!=(*L)&&j<i-1){//找到被插入序号的前一个位置
       p=p->next;//向后移动一个
       j++; 
    }
    if(p==(*L)||(i-j)>1) return FALSE;//序号在无效范围内
    s=(CDLinkList)malloc(sizeof(CDNode));//创建一个新结点
    s->data=e;//赋值
    s->next=p->next;//让该结点指向p（插入位置的前一个结点）的下一个结点
    p->next->prior=s;//让p的下一个结点的前驱指向该结点
    s->prior=p;//让该结点的前驱指向p
    p->next=s; //让p指向该结点  
}
删除操作。删除表中L中第i个位置的元素，并用e返回删除的元素。
/*删除*/
int ListDelete_CDLink(CDLinkList *L,int i,ElemType *e){
    int j=0;//空表序号为0
    CDNode *p=(*L);//p指向头结点
    CDNode *q;//q用来指向被删除的结点
    while (p->next!=(*L)&&j<i-1){//找到要被删除结点的前一个结点
        p=p->next;//向后移动一个
        j++;
    }
    if ((p->next)==(*L)||i<1) return FALSE;//序号在无效范围内
    q=p->next;//让q指向被删除的结点
    p->next=q->next;//让p（被删除结点的前一个结点）指向被删除结点的下一个结点，q从链表中断开
    q->next->prior=p;//让删除结点的下一个结点的前驱指向p；
    *e=q->data;//把被删除的结点的值返回
    free(q);//释放该结点
    return TRUE; //删除成功
}

三、 循环单链表完整源码

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

#define TRUE 1
#define FALSE 0

typedef struct{
    int id;//对应表中的id
    char name[100];//对应表中的姓名
    char description[200];//对应表中的描述
}ElemType;//此处的ElemType是个类型名

typedef struct CNode{
    ElemType data;//数据域
    struct CNode *next;//指针域
}CNode,*CLinkList;

/*初始化*/
int InitList_CLink(CLinkList *L){
    *L=(CLinkList)malloc(sizeof(CNode));//创建头结点，并让头指针指向头结点
    if (!(*L)) return FALSE;//分配失败
    (*L)->next=(*L);//初始化为头指针
    return TRUE;//初始化成功
}

/*头插法创建循环单链表*/
int create_HeadInsert(CLinkList *L,ElemType a[],int n){
 // InitList_CLink(L);
    CNode *s;//用来指示新创建的结点
    int i;
    for(i=n-1;i>=0;i--){//由于头插法是倒序插入，所以这里我们从数组最后开始遍历
        s=(CLinkList)malloc(sizeof(CNode));//创建一个新结点
        s->data=a[i];//为结点赋值
        s->next=(*L)->next;//让该结点指向第一个结点
        (*L)->next=s;//让头结点指向该结点
    }
}
/*尾插法创建循环单链表*/
int create_TailInsert(CLinkList *L,ElemType a[],int n){
 // InitList_CLink(L);
    CNode *s,*r=(*L); //s用来指示新创建的结点，r用来移动以连接链表
    int i;
    for(i=0;i<n;i++){//遍历数组
        s=(CLinkList)malloc(sizeof(CNode));//创建一个新结点
        s->data=a[i];//为结点赋值
        r->next=s;//r始终指向链表的尾端，这里将新结点连接到r的后面
        r=s;//r移动到链表尾端
    }
    r->next=(*L);//结束时，最后一个结点的指针域赋值为头指针
}

/*求表长*/
int Length_CLink(CLinkList L){
    int i=0;//空表返回0
    CNode *s=L;
    while (s->next!=L){//遍历，直到尾结点，空表不进入循环
        s=s->next;//向后移动一个
        i++;//表长加一
    }
    return i;//返回表长
}

/*插入*/
int ListInsert_CLink(CLinkList *L,int i,ElemType e){
    int j=0;//空表序号为0
    CNode *p=(*L);//p指向头结点
    CNode *s;//s用来指示新创建的结点
    while (p->next!=(*L)&&j<i-1){//找到被插入序号的前一个位置
       p=p->next;//向后移动一个
       j++; 
    }
    if(p==(*L)||(i-j)>1) return FALSE;//序号在无效范围内
    s=(CLinkList)malloc(sizeof(CNode));//创建一个新结点
    s->data=e;//赋值
    s->next=p->next;//让该结点指向p（插入位置的前一个结点）的下一个结点
    p->next=s; //让p指向该结点  
}

/*删除*/
int ListDelete_CLink(CLinkList *L,int i,ElemType *e){
    int j=0;//空表序号为0
    CNode *p=(*L);//p指向头结点
    CNode *q;//q用来指向被删除的结点
    while (p->next!=(*L)&&j<i-1){//找到要被删除结点的前一个结点
        p=p->next;//向后移动一个
        j++;
    }
    if ((p->next)==(*L)||i<1) return FALSE;//序号在无效范围内
    q=p->next;//让q指向被删除的结点
    p->next=q->next;//让p（被删除结点的前一个结点）指向被删除结点的下一个结点，q从链表中断开
    *e=q->data;//把被删除的结点的值返回
    free(q);//释放该结点
    return TRUE; //删除成功
}

/*按位查找*/
int GetElem_CList(CLinkList L,int i,ElemType *e){
    CNode *p=L; //p指向头结点
    int j=0;//空表序号为0
    while (p->next!=L&&j<i){//找到第i个位置
        p=p->next;//向后移动一个
        ++j;
    }
    if(p==L||i<1)  return FALSE; //i不在有效范围内
    *e=p->data; //把第i个结点的值用e返回
    return TRUE;
}

/*按值查找*/
int LocateElem_CList(CLinkList L,ElemType e,int *i){
    CNode *s=L;
    int j=0;//空表序号为0
    while (s->next!=L){//遍历链表
        s=s->next;//向后移动
        j++;//序号加一
        if (s->data.id==e.id){//这里我们只用id来判断元素的值是否相等，假设id唯一
            *i=j;//如果相等，用i返回序号
            return TRUE;//查找成功
        }    
    }
    return FALSE;
}

/*打印*/
void PrintList_CLink(CLinkList L){
    CNode *s=L;
    int i=0;//空表序号为0
    while (s->next!=L)//遍历表
    {
        s=s->next;
        i++;
        printf("第%d行：id=%d,name=%s,description=%s\n",i,s->data.id,s->data.name,s->data.description);
    }
}

/*销毁循环单链表*/
void DestroyCList(CLinkList *L){
    while((*L)->next!=(*L)) {//遍历
    	CNode *p=(*L)->next;
    	(*L)->next=p->next;
    	free(p);
	}
}

int main(){
    CLinkList L;
    int i=InitList_CLink(&L);
    if(i==1){
        printf("初始化成功\n");
    }
    printf("\n");    
///
    ElemType a[4]={
        {1,"史强","最强辅助"},
        {2,"章北海","我不需要钢印，我是自己思想的主人"},
        {3,"罗辑","人类不感谢罗辑"},
        {4,"维德","失去人性，失去很多。失去兽性，失去一切"}
    };  
    //create_HeadInsert(&L,a,4);
    create_TailInsert(&L,a,4);  
    PrintList_CLink(L);
    printf("\n");    
///
    ElemType e={5,"xxx","xxxxxxxxxxxxxxxxxxxx"};
    ListInsert_CLink(&L,5,e); 
    PrintList_CLink(L);
    printf("\n");    
///
    ListDelete_CLink(&L,5,&e);
    PrintList_CLink(L);
    printf("被删除的元素：id=%d,name=%s,description=%s\n",e.id,e.name,e.description);
    printf("\n");    
///
    GetElem_CList(L,4,&e);
    printf("查询到的元素：id=%d,name=%s,description=%s\n",e.id,e.name,e.description);
    printf("\n");    
//
    LocateElem_CList(L,a[2],&i);
    printf("查询到的位序为：%d\n",i);
    printf("\n");    
//
    i=Length_CLink(L);
    printf("表长为：%d\n",i);
    printf("\n");    
//
    DestroyCList(&L);
    PrintList_CLink(L);
}

运行结果：

初始化成功

第1行：id=1,name=史强,description=最强辅助
第2行：id=2,name=章北海,description=我不需要钢印，我是自己思想的主人
第3行：id=3,name=罗辑,description=人类不感谢罗辑
第4行：id=4,name=维德,description=失去人性，失去很多。失去兽性，失去一切

第1行：id=1,name=史强,description=最强辅助
第2行：id=2,name=章北海,description=我不需要钢印，我是自己思想的主人
第3行：id=3,name=罗辑,description=人类不感谢罗辑
第4行：id=4,name=维德,description=失去人性，失去很多。失去兽性，失去一切
第5行：id=5,name=xxx,description=xxxxxxxxxxxxxxxxxxxx

第1行：id=1,name=史强,description=最强辅助
第2行：id=2,name=章北海,description=我不需要钢印，我是自己思想的主人
第3行：id=3,name=罗辑,description=人类不感谢罗辑
第4行：id=4,name=维德,description=失去人性，失去很多。失去兽性，失去一切
被删除的元素：id=5,name=xxx,description=xxxxxxxxxxxxxxxxxxxx

查询到的元素：id=4,name=维德,description=失去人性，失去很多。失去兽性，失去一切

查询到的位序为：3

表长为：4

四、 循环双链表完整源码

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

#define TRUE 1
#define FALSE 0

typedef struct{
    int id;//对应表中的id
    char name[100];//对应表中的姓名
    char description[200];//对应表中的描述
}ElemType;//此处的ElemType是个类型名

typedef struct CDNode{
    ElemType data;//数据域
    struct CDNode *prior;//指针域
    struct CDNode *next;//指针域
}CDNode,*CDLinkList;

/*初始化*/
int InitList_CDLink(CDLinkList *L){
    *L=(CDLinkList)malloc(sizeof(CDNode));//创建头结点，并让头指针指向头结点
    if (!(*L)) return FALSE;//分配失败
    (*L)->prior=(*L);//初始化为头指针
    (*L)->next=(*L);//初始化为头指针
    return TRUE;//初始化成功
}

/*头插法创建循环双链表*/
int create_HeadInsert(CDLinkList *L,ElemType a[],int n){
 // InitList_CLink(L);
    CDNode *s;//用来指示新创建的结点
    int i;
    for(i=n-1;i>=0;i--){//由于头插法是倒序插入，所以这里我们从数组最后开始遍历
        s=(CDLinkList)malloc(sizeof(CDNode));//创建一个新结点
        s->data=a[i];//为结点赋值
        s->next=(*L)->next;//让该结点指向第一个结点
        (*L)->next->prior=s;//第一个结点的前驱指向该结点
        s->prior=(*L);//该节点的前驱指向头结点
        (*L)->next=s;//让头结点指向该结点
    }
}
/*尾插法创建循环双链表*/
int create_TailInsert(CDLinkList *L,ElemType a[],int n){
 // InitList_CLink(L);
    CDNode *s,*r=(*L); //s用来指示新创建的结点，r用来移动以连接链表
    int i;
    for(i=0;i<n;i++){//遍历数组
        s=(CDLinkList)malloc(sizeof(CDNode));//创建一个新结点
        s->data=a[i];//为结点赋值
        r->next=s;//r始终指向链表的尾端，这里将新结点连接到r的后面
        s->prior=r;//该结点的前驱指向r
        r=s;//r移动到链表尾端
    }
    r->next=(*L);//结束时，最后一个结点的指针域赋值为头指针
}

/*求表长*/
int Length_CDLink(CDLinkList L){
    int i=0;//空表返回0
    CDNode *s=L;
    while (s->next!=L){//遍历，直到尾结点，空表不进入循环
        s=s->next;//向后移动一个
        i++;//表长加一
    }
    return i;//返回表长
}

/*插入*/
int ListInsert_CDLink(CDLinkList *L,int i,ElemType e){
    int j=0;//空表序号为0
    CDNode *p=(*L);//p指向头结点
    CDNode *s;//s用来指示新创建的结点
    while (p->next!=(*L)&&j<i-1){//找到被插入序号的前一个位置
       p=p->next;//向后移动一个
       j++; 
    }
    if(p==(*L)||(i-j)>1) return FALSE;//序号在无效范围内
    s=(CDLinkList)malloc(sizeof(CDNode));//创建一个新结点
    s->data=e;//赋值
    s->next=p->next;//让该结点指向p（插入位置的前一个结点）的下一个结点
    p->next->prior=s;//让p的下一个结点的前驱指向该结点
    s->prior=p;//让该结点的前驱指向p
    p->next=s; //让p指向该结点  
}

/*删除*/
int ListDelete_CDLink(CDLinkList *L,int i,ElemType *e){
    int j=0;//空表序号为0
    CDNode *p=(*L);//p指向头结点
    CDNode *q;//q用来指向被删除的结点
    while (p->next!=(*L)&&j<i-1){//找到要被删除结点的前一个结点
        p=p->next;//向后移动一个
        j++;
    }
    if ((p->next)==(*L)||i<1) return FALSE;//序号在无效范围内
    q=p->next;//让q指向被删除的结点
    p->next=q->next;//让p（被删除结点的前一个结点）指向被删除结点的下一个结点，q从链表中断开
    q->next->prior=p;//让删除结点的下一个结点的前驱指向p；
    *e=q->data;//把被删除的结点的值返回
    free(q);//释放该结点
    return TRUE; //删除成功
}

/*按位查找*/
int GetElem_CDList(CDLinkList L,int i,ElemType *e){
    CDNode *p=L; //p指向头结点
    int j=0;//空表序号为0
    while (p->next!=L&&j<i){//找到第i个位置
        p=p->next;//向后移动一个
        ++j;
    }
    if(p==L||i<1)  return FALSE; //i不在有效范围内
    *e=p->data; //把第i个结点的值用e返回
    return TRUE;
}

/*按值查找*/
int LocateElem_CDList(CDLinkList L,ElemType e,int *i){
    CDNode *s=L;
    int j=0;//空表序号为0
    while (s->next!=L){//遍历链表
        s=s->next;//向后移动
        j++;//序号加一
        if (s->data.id==e.id){//这里我们只用id来判断元素的值是否相等，假设id唯一
            *i=j;//如果相等，用i返回序号
            return TRUE;//查找成功
        }    
    }
    return FALSE;
}

/*打印*/
void PrintList_CDLink(CDLinkList L){
    CDNode *s=L;
    int i=0;//空表序号为0
    while (s->next!=L)//遍历表
    {
        s=s->next;
        i++;
        printf("第%d行：id=%d,name=%s,description=%s\n",i,s->data.id,s->data.name,s->data.description);
    }
}

/*销毁循环双链表*/
void DestroyCDList(CDLinkList *L){
    while((*L)->next!=(*L)) {//遍历
    	CDNode *p=(*L)->next;
    	(*L)->next=p->next;
    	free(p);
	}
}

int main(){
    CDLinkList L;
    int i=InitList_CDLink(&L);
    if(i==1){
        printf("初始化成功\n");
    }
    printf("\n");    
///
    ElemType a[4]={
        {1,"史强","最强辅助"},
        {2,"章北海","我不需要钢印，我是自己思想的主人"},
        {3,"罗辑","人类不感谢罗辑"},
        {4,"维德","失去人性，失去很多。失去兽性，失去一切"}
    };  
   // create_HeadInsert(&L,a,4);
    create_TailInsert(&L,a,4);  
    PrintList_CDLink(L);
    printf("\n");    
///
    ElemType e={5,"xxx","xxxxxxxxxxxxxxxxxxxx"};
    ListInsert_CDLink(&L,5,e); 
    PrintList_CDLink(L);
    printf("\n");    
///
    ListDelete_CDLink(&L,5,&e);
    PrintList_CDLink(L);
    printf("被删除的元素：id=%d,name=%s,description=%s\n",e.id,e.name,e.description);
    printf("\n");    
///
    GetElem_CDList(L,4,&e);
    printf("查询到的元素：id=%d,name=%s,description=%s\n",e.id,e.name,e.description);
    printf("\n");    
//
    LocateElem_CDList(L,a[2],&i);
    printf("查询到的位序为：%d\n",i);
    printf("\n");    
//
    i=Length_CDLink(L);
    printf("表长为：%d\n",i);
    printf("\n");    
//
    DestroyCDList(&L);
    PrintList_CDLink(L);
}

运行结果：

初始化成功

第1行：id=1,name=史强,description=最强辅助
第2行：id=2,name=章北海,description=我不需要钢印，我是自己思想的主人
第3行：id=3,name=罗辑,description=人类不感谢罗辑
第4行：id=4,name=维德,description=失去人性，失去很多。失去兽性，失去一切

第1行：id=1,name=史强,description=最强辅助
第2行：id=2,name=章北海,description=我不需要钢印，我是自己思想的主人
第3行：id=3,name=罗辑,description=人类不感谢罗辑
第4行：id=4,name=维德,description=失去人性，失去很多。失去兽性，失去一切
第5行：id=5,name=xxx,description=xxxxxxxxxxxxxxxxxxxx

第1行：id=1,name=史强,description=最强辅助
第2行：id=2,name=章北海,description=我不需要钢印，我是自己思想的主人
第3行：id=3,name=罗辑,description=人类不感谢罗辑
第4行：id=4,name=维德,description=失去人性，失去很多。失去兽性，失去一切
被删除的元素：id=5,name=xxx,description=xxxxxxxxxxxxxxxxxxxx

查询到的元素：id=4,name=维德,description=失去人性，失去很多。失去兽性，失去一切

查询到的位序为：3

表长为：4
秋千水竹马道
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
详解循环链表（数据结构C语言）
m0_59068067的博客
10-15 1113
本文简单介绍了循环链表的基本概念，特点以及基础运算，并附上了代码以及结果，希望以后复习时可以加深自己的印象；在运行过程中，总有一些卡壳的部分，在朋友的指导下，修改代码并顺利完成结果。
循环链表（C语言)
weixin_54454406的博客
10-15 213
注意：我们需要首先创建一个新的节点，然后调整节点的指针以适应新的链表结构。否则，将其添加到尾节点的后面，并更新尾节点为新节点。当插入新节点时，利用头节点的指针域始终指向头节点的后继节点的特点，来对新插入的节点完成前驱后继节点的设置。1.4：删除指定节点：前一个节点的 next 指针指向当前节点的下一个节点，从而删除当前节点。1.5：查找指定值：遍历链表中的每个节点，如果节点的数据等于目标值，就返回该节点在链表中的位置。头和尾插法建立：在循环链表的尾部或指定位置插入一个新的节点，更新后继指针和头节点指针。
数据结构之循环链表（C语言）
sskdspdl的博客
09-03 665
用C语言实现循环链表
c语言 循环程序 简单,C语言循环链表的简单应用
weixin_36143628的博客
05-19 155
/*****************************************************************************本程序对循环链表进行处理，分别对链表的长度进行设定、插入、删除和释放，并且通过对操作者的限制来防止因操作者的操作失误而带来的不可设想的后果，本程序有较强的安全性程序的细节如下:**********************************...
【数据结构】【C语言】存放任何数据，双向循环链表定义和实现
痛苦的时候装出幸福相，这不是那么难做到的事
06-04 174
前言 链表头不是链表节点，不存放数据！！！所以链表头中存放的链表节点不能是指针！！！ //双向循环链表 //链表节点 struct ilistnode { struct ilistnode* p, * n; //前后指针 }; //链表头 struct ilist { struct ilistnode head; //链表头，不存放数据，这样很方便移动头元素的位置 int size; //链表节点个数 }; /*ilist*/ //创建双向链表 ipublic stru
全网最详细的-线性表的链式存储
最新发布
12-26
在实现链式存储时，可以使用单链表、双链表或循环链表等不同的结构来实现。单链表包含一个指针域，指向下一个节点；双链表包含两个指针域，分别指向前一个节点和后一个节点；循环链表是一种特殊的链表，尾节点的指针...
c语言数据结构实验：掌握线性表的链式存储结构 熟练掌握循环链表的存储特征和建立方法，掌握线性表的链式存储结构 下面是源码的txt
10-13
假设在长度大于1的单循环链表中，既无头结点也无头指针。s 为指向某个结点的指针，试编写算法删除结点*s 的直接前驱结点。 2、已知由单链表表示的线性表中，含有三类字符的数据元素(如:字母、数字和其它字符)，设计...
数据结构-C语言版-第二版(严蔚敏)-第3章-栈和队列-答案.doc
12-06
"数据结构-C语言版-第二版(严蔚敏)-第3章-栈和队列-答案.doc" 本资源主要讲解了数据结构中的栈和队列两种基本数据结构。栈是一种后进先出的线性表，队列是一种先进先出的线性表。栈和队列都是基本的数据结构，可以...
线性表--顺序表操作
12-12
这有线性表的操作:顺序存储,链存储结构, 单链表,顺序表,循环链表,双向链表
数据结构教学课件：第3-2讲 线性表的链式存储结构-2.pdf
06-01
循环链表是一种特殊的链式存储结构，它的最后一个结点的指针域指向第一个结点或表头结点，从而形成一个环。循环链表的运算与线性链表基本一致，但两者判断是否到表尾的条件不同：线性表判断某结点的链域是否为空，而...
链式存储-循环链表
z1360408752的博客
04-12 264
转载于:https://www.cnblogs.com/dakewei/p/11378713.html 本文为在这位前辈的基础上做了些许改动，添加了一些自己的感悟以及注释。 另外，非常感谢这位前辈的这篇博客，对我的学习起到了很大的帮助，不胜感激。 循环链表 在单链表中，存在这样一个问题，如果不从头结点出发，就无法访问到全部结点。 而为了解决这个问题，只需要将单链表终端结点的指针域由空指针改为指向头...
C语言丨线性表（四）：循环链表
weixin_60921752的博客
01-20 772
本文在介绍线性表的基本概念的基础上，重点介绍单循环链表和双循环链表及相应的算法。
顺序表的插入与删除java_顺序表的基本操作——插入、删除
weixin_36358217的博客
02-27 1478
顺序表的基本操作——插入、删除1、顺序表的基本操作——插入ListInsert(&L,i,e):插入操作。在表中的第i个位置上插入指定元素e。#include#define MaxSize 10//定义最大长度typedef struct {int data[MaxSize];//用静态的“数组”存放数据元素int length;//顺序表的当前元素}SqList;//顺序表的类型定义vo...
顺序表的实现及操作【C语言最详细版】
一同进步，一同追梦
09-28 5351
数据结构 线性表中顺序表的实现和测试，让你理解顺序表底层物理逻辑，和实现相应功能的创建。
线性表的三种基本操作（插入、删除、操作）！！！
Mrllir的博客
09-12 8824
C语言定义： #define maxsize 线性表肯定达到的最大长 typedef struct //结构体 { ElemType elem[maxsize]; int length; }SeqList; SeqList L;或 SeqList *L; 注意：区分元素的序号和数组的下标，如a1的序号为1，而其对应的数组元素L.elem[0]。或者不使用下标为0的单元，序号和下标保持一致，多占用一个元素空间即可。 基本运算： ①查找操作 按序号查找GetData(L,i);要求查找..
单链表实现“插入”和“删除”操作
weixin_34378045的博客
11-03 1109
在单链表中，又如何实现“插入”和“删除”操作呢？插入操作： 假设我们要在线性表的两个数据元素a和b之间插入一个数据元素x，已知p为其单链表存储结构中指向结点a的指针。为插入数据元素x，首先要生成一个数据域为x的结点，然后插入在单链表中。根据插入操作的逻辑定义，还需修改结点a中的指针域，令其指向结点x，而结点x中的指针域应该指向b结点，从而实现3个元素a，b和x之间逻...
顺序表的插入与删除（简单版）--C语言
李小阳先森的学习日记
11-16 8267
如标题，只是一个简单的顺序表的插入和删除，希望能帮到各位初学的同学。只起参考作用
数据结构——你好，线性表( ^- ^ )
weixin_52621323的博客
12-12 3075
结合大量生动形象的演示带你一点一点清楚线性表原来是这么一回事儿~。顺便蹭蹭可爱的波吉王子热度
C语言实现单向（循环）链表的创建和遍历
lightingfuture的博客
08-24 8312
本代码在QT控制台环境下测试通过，如果在其他IDE下，注意修改包含的打印头文件即可。 include include include /* *2018-08-24 13:23:03 * 单向链表测试 * 包括循环链表的实现 */ using namespace std; typedef struct Node{ struct Node *next; ...
线性表的链式存储结构
09-06
线性表的链式存储结构是使用链式方式将线性表中的元素存储起来。链表可以分为单链表、循环链表和双链表。在单链表中，每个结点都包含指向下一个结点的指针。循环链表是在单链表的基础上，将最后一个结点的指针指向头...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

秋千水竹马道

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值