数据结构：双向循环链表的c语言实现方法一

最新推荐文章于 2023-10-15 22:38:13 发布
最新推荐文章于 2023-10-15 22:38:13 发布
阅读量236 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45619852/article/details/120515723
版权

双向环链

首先双向循环链表每一个节点需要有一个指向上一个节点地址的指针与指向下一个节点地址的指针，并且还有一个需要保存的数据。保存数据的类型可以这样写：

#define data_t int
struct llist_node
{
	data_t *data;
	struct llist_node *prev;
	struct llist_node *next;
}

链表中需要保存 什么类型的数据就更改这个宏定义就可以了，但是这样其实很麻烦，有一个百搭的数据类型void,用下面这种写法更通用，需要什么样的数据类型自己进行强转就行了。

struct llist_node
{
	void *data;
	struct llist_node *prev;
	struct llist_node *next;
}

但是使用void *会有个问题，这个指针指向的地址需要申请一个多大的内存去保存数据？所以需要用户指定数据类型的大小，这时候就可以添加一个头节点来保存这个信息，并且头节点可以作为链表的起点，用户每次对链表进行操作只需要有这个头节点地址就行。

typedef struct llist_head
{
	int size;
	struct llist_node head;
}llist;

链表中每个节点会保存上一个节点和下一个节点的地址，并且链表的入口为头节点，结构图就如下：
在这里插入图片描述
其中data需要根据头节点中的size信息开辟内存保存数据。
首先写链表的创建与销毁函数

// .h文件中
struct llist_node
{
	void *data;
	struct llist_node *prev;
	struct llist_node *next;
}

typedef struct llist_head
{
	int size;
	struct llist_node head;
}llist;

// 创建链表 
// 第一个参数为节点中数据的大小
llist *llist_create(int size);
// 销毁链表
// 第一个参数为需要销毁的链表
void llist_destroy(llist *);

// .c文件中实现
llist *llist_create(int size)
{
    llist *new = NULL;
    // 给链表头分配空间
    new = malloc(sizeof(*new));
    if(new == NULL) 
        return NULL;
	// 保存data的大小在头部size中
    new->size = size;
    // 将头节点的数据指向NULL，头节点中data不需要保存数据
    new->head.data = NULL;
    // 头节点的上一个和下一个节点指向自身
    new->head.prev = &new->head;
    new->head.next = &new->head;

    return new;
}

void llist_destroy(llist *list)
{
    struct llist_node *cur,*next;
    for(cur = list->head.next;cur != &list->head;cur = next)
    {
    	// 因为要销毁cur所以在销毁之前将下一个节点的地址保存在next变量中
        next = cur->next;
        // 释放掉节点中数据的空间
        free(cur->data);
        // 释放节点
        free(cur);
    }
    // 释放链表头
    free(list);
}

目前通过llist_create函数获取到了链表头节点，下面的增删改查都通过操作这个头节点操作就行。
首先添加插入方法，插入分为前插与后插，前插指在头节点与第一个节点之间插入，后插指的是在最后一个节点的后面插入。前插的话需要将当前节点的下个节点指向头节点的下个节点，当前节点的上一个节点指向头节点的head地址，然后分别再让当前节点的上一个节点的下一个节点指向自己，下一个节点的上一个节点指向自己。后插则是当前节点的上一个节点指向头节点的上一个节点，当前节点的下一个节点指向头节点的head地址。

 int llist_insert(llist *list,int mode,const void *data)
{
    // 如果操作的链表为空就返回
    if(list == NULL)
        return -1;

    struct llist_node *new = NULL;
	// 为当前节点申请内存
    new = malloc(sizeof(*new));
    if(new == NULL)
        return -2;
    // 给当前节点下的data申请内存 
    new->data = malloc(list->size);
    if(new->data == NULL)
    {
        free(new);
        return -3;
    }
    // 知道数据的大小，用这个方法拷贝数据最合适
    // 将传入数据保存到当前节点的data中
    memcpy(new->data,data,list->size);

	// 前插或者后插
    if(mode == INSERT_FORWARD)
    {
        new->next = list->head.next;
        new->prev = &list->head;
    }
    else if(mode == INSERT_BACKWARD)
    {
        new->prev = list->head.prev;
        new->next = &list->head;
    }
    new->prev->next = new;
    new->next->prev = new;

    return 0;
}

接着写一个 show方法来遍历链表里面的数据。首先明确如何才能将 链表里面 的数据打印出来，以为我们封装的方法要通用，所以不能直接写数据的类型，不知道数据的具体类型打印的方法当然就不能实现，所以这里让用户 自己 实现自己的打印函数，我们给他定义一个函数指针，我们 只负责遍历 的时候调用用户给的 函数 。相关代码如下：

// .h中
typedef void (*llist_print)(const void *data);
// 打印链表中存放的数据
// 第一个参数为要操作的链表，第二个参数为打印函数实现，提供给用户了接口
// 该函数实际只是遍历函数，通过用户提供的函数打印数据
void llist_show(llist *,llist_print );

// .c中
void llist_show(llist *list,llist_print func)
{
    struct llist_node *cur = NULL;
    for(cur = list->head.next;cur != &list->head;cur = cur->next)
    {
        func(cur->data);
    }
}

//  调用部分示例
struct student
{
    char name[20];
    int age;
    int id;
};

void student_print(const void *data)
{
    struct student std = *((struct student *)data);
    printf("name : %s\r\n",std.name);
    printf("age : %d\r\n",std.age);
    printf("id : %d\r\n",std.id);
}

int main()
{
	...
	llist_show(head,student_print);
	...
}

接下来实现find函数，find函数有两种方法，一种是通过返回值将查找到 的 结果返回给用户 ，失败 返回空。另一种方法是回填数据到用户指定的变量地址中，成功返回0，失败返回非0.这里我们选用第二种方式。
find函数在实现过程中可以拆分出共有 的 部分 给其他函数使用，比如删除某个节点，删除并获取某个节点数据都会用到通过关键词查找数据的方法，所以将这个部分 封装成一个小函数供其他函数使用。

static struct llist_node *__find(llist *list,const void *key,llist_cmp cmp)
{
    struct llist_node *cur = NULL;
    for(cur = list->head.next;cur != &list->head;cur = cur->next)
    {
        if(cmp(key,cur->data))
            return cur;
    }
    return cur;
}

通过条件查找封装的这个函数的第一个参数为要操作的链表的头，第二个参数为查找节点内容的关键词，第三个参数为用户自己实现的内容，因为我们并不知道数据是什么类型的，里面又有 什么内容，所以这部分让用户 自己实现，我们只负责在遍历时调用用户给的函数。返回值为查找到的节点。这个用户自己写的比较函数，当找到了与key匹配的值后返回1，没找到返回0。
接着就可以 实现find、delete、fetch函数了，区别时find只是找到数据回填给用户，delete是找到数据并且将其删除，fetch是找到数据将其删除，并将删除的内容回填给用户，delete和fetch都涉及脱链操作，脱链是将当前节点的上一个节点的下一个节点指向当前节点的下一个节点，当前节点的下一个节点 的上一个节点指向当前节点的上一个节点，然后再将当前节点中的data释放，再释放当前节点。实现如下：

// .h
typedef int (*llist_cmp)(const void *key,const void *data);

// 删除链表中的一个节点
// 第一个参数为要操作的链表，第二个参数为删除内容的关键词
// 第三个为用户需要自己实现的比较函数
int llist_delete(llist *,const void *key,llist_cmp cmp);

// 删除链表中的一个节点并返回删除节点内的数据
// 第一个参数为要操作的链表，第二个参数为要删除并获取的节点内容的关键词 
// 第三个参数为用户需要自己实现的比较函数，第四个参数用于保存获取的数据
int llist_fetch(llist *,const void *key,llist_cmp cmp,void *data);

// 按条件查找链表中的数据
// 第一个参数为要操作的链表,第二个参数为要查询内容的关键词
// 第三个参数为需要用户自己实现的比较函数
int llist_find(llist *,const void *key,llist_cmp cmp,void *data);

// .c实现
int llist_fetch(llist *list,const void *key,llist_cmp cmp,void *data)
{
    struct llist_node *ret = __find(list,key,cmp);
    if(data == NULL)
        return -1;
    if(ret == &list->head)
        return -2;
    memcpy(data,ret->data,list->size);

    ret->prev->next = ret->next;
    ret->next->prev = ret->prev;

    free(ret->data);
    free(ret);

    return 0;
}

int llist_delete(llist *list,const void *key,llist_cmp cmp)
{
    struct llist_node *ret = __find(list,key,cmp);
    if(ret == &list->head)
        return -1;
    ret->prev->next = ret->next;
    ret->next->prev = ret->prev;

    free(ret->data);
    free(ret);

    return 0;
}

int llist_find(llist *list,const void *key,llist_cmp cmp,void *data)
{
    struct llist_node *ret = __find(list,key,cmp);
    if(ret == &list->head)
        return -1;
    if(data == NULL)
        return -2;
    memcpy(data,ret->data,list->size);

    return 0;
}

// 使用示例
struct student
{
    char name[20];
    int age;
    int id;
};

int id_cmp(const void *key,const void *data)
{
    int id = *((int *)key);
    struct student std = *((struct student *)data);
    return !(id - std.id);
}

int main()
{
	...
	int id=1,id1=2;
	struct student temp;
	llist_find(head,&id,id_cmp,&temp);
	llist_fetch(head,&id1,id_cmp,&temp);
	llist_delete(head,&id,id_cmp);
	...
}

下面为整个工程的代码
llist.h

#ifndef LLIST_H__
#define LLIST_H__

#define INSERT_FORWARD      0
#define INSERT_BACKWARD     1

typedef void (*llist_print)(const void *data);
typedef int (*llist_cmp)(const void *key,const void *data);


struct llist_node
{
    void *data;
    struct llist_node *prev;
    struct llist_node *next;
};

typedef struct llist_head
{
    int size;
    struct llist_node head;
}llist;

// 创建一个链表，输入参数为链表内要存储的数据类型大小
// 返回值为初始化好的链表头指针，使用完后需要通过llist_destroy函数释放
llist *llist_create(int size);

// 向链表内增加一个节点
// 第一个参数为要操作的链表，第二个参数为插入方式，前插或者后插
// 第三个参数为要插入的数据
int llist_insert(llist *,int mode,const void *data);

// 删除链表中的一个节点
// 第一个参数为要操作的链表，第二个参数为删除内容的关键词
// 第三个为用户需要自己实现的比较函数
int llist_delete(llist *,const void *key,llist_cmp cmp);

// 删除链表中的一个节点并返回删除节点内的数据
// 第一个参数为要操作的链表，第二个参数为要删除并获取的节点内容的关键词 
// 第三个参数为用户需要自己实现的比较函数，第四个参数用于保存获取的数据
int llist_fetch(llist *,const void *key,llist_cmp cmp,void *data);

// 按条件查找链表中的数据
// 第一个参数为要操作的链表,第二个参数为要查询内容的关键词
// 第三个参数为需要用户自己实现的比较函数
int llist_find(llist *,const void *key,llist_cmp cmp,void *data);

// 打印链表中存放的数据
// 第一个参数为要操作的链表，第二个参数为打印函数实现，提供给用户了接口
// 该函数实际只是遍历函数，通过用户提供的函数打印数据
void llist_show(llist *,llist_print );


// 释放链表所占用的内存空间
void llist_destroy(llist *);
#endif

llist.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "llist.h"

llist *llist_create(int size)
{
    llist *new = NULL;
    // 给链表头分配空间
    new = malloc(sizeof(*new));
    if(new == NULL)
        return NULL;

    new->size = size;
    new->head.data = NULL;
    new->head.prev = &new->head;
    new->head.next = &new->head;

    return new;
}

int llist_insert(llist *list,int mode,const void *data)
{
    // 如果操作的链表为空就返回
    if(list == NULL)
        return -1;

    struct llist_node *new = NULL;

    new = malloc(sizeof(*new));
    if(new == NULL)
        return -2;
    new->data = malloc(list->size);
    if(new->data == NULL)
    {
        free(new);
        return -3;
    }
    memcpy(new->data,data,list->size);

    if(mode == INSERT_FORWARD)
    {
        new->next = list->head.next;
        new->prev = &list->head;
    }
    else if(mode == INSERT_BACKWARD)
    {
        new->prev = list->head.prev;
        new->next = &list->head;
    }
    new->prev->next = new;
    new->next->prev = new;

    return 0;
}

static struct llist_node *__find(llist *list,const void *key,llist_cmp cmp)
{
    struct llist_node *cur = NULL;
    for(cur = list->head.next;cur != &list->head;cur = cur->next)
    {
        if(cmp(key,cur->data))
            return cur;
    }
    return cur;
}


int llist_fetch(llist *list,const void *key,llist_cmp cmp,void *data)
{
    struct llist_node *ret = __find(list,key,cmp);
    if(data == NULL)
        return -1;
    if(ret == &list->head)
        return -2;
    memcpy(data,ret->data,list->size);

    ret->prev->next = ret->next;
    ret->next->prev = ret->prev;

    free(ret->data);
    free(ret);

    return 0;
}


int llist_delete(llist *list,const void *key,llist_cmp cmp)
{
    struct llist_node *ret = __find(list,key,cmp);
    if(ret == &list->head)
        return -1;
    ret->prev->next = ret->next;
    ret->next->prev = ret->prev;

    free(ret->data);
    free(ret);

    return 0;
}


int llist_find(llist *list,const void *key,llist_cmp cmp,void *data)
{
    struct llist_node *ret = __find(list,key,cmp);
    if(ret == &list->head)
        return -1;
    if(data == NULL)
        return -2;
    memcpy(data,ret->data,list->size);

    return 0;
}

void llist_show(llist *list,llist_print func)
{
    struct llist_node *cur = NULL;
    for(cur = list->head.next;cur != &list->head;cur = cur->next)
    {
        func(cur->data);
    }
}

void llist_destroy(llist *list)
{
    struct llist_node *cur,*next;
    for(cur = list->head.next;cur != &list->head;cur = next)
    {
        next = cur->next;
        free(cur->data);
        free(cur);
    }
    free(list);
}

Makefile

out:main.o llist.o
    $(CC) $^ -o $@

.PHONY:clean

clean:
    -rm -rf *.o out

main.c

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

struct student
{
    char name[20];
    int age;
    int id;
};


void student_print(const void *data)
{
    struct student std = *((struct student *)data);
    printf("name : %s\r\n",std.name);
    printf("age : %d\r\n",std.age);
    printf("id : %d\r\n",std.id);
}

int id_cmp(const void *key,const void *data)
{
    int id = *((int *)key);
    struct student std = *((struct student *)data);
    return !(id - std.id);
}

int main(int argc,char **argv)
{
    llist *head = NULL;
    head = llist_create(sizeof(struct student));
    if(head ==  NULL)
        exit(1);
    for(int i=0;i<10;i++)
    {
        struct student std;
        snprintf(std.name,sizeof(std.name),"student%d",i);
        std.age = i;
        std.id = i;
        llist_insert(head,INSERT_BACKWARD,&std);
    }


    llist_show(head,student_print);

    int id = 1;
    int id1 = 9;
    int id2 = 2;
    llist_delete(head,&id,id_cmp);
    llist_delete(head,&id1,id_cmp);
    llist_delete(head,&id2,id_cmp);

    llist_show(head,student_print);

    int id3 = 4;
    struct student temp={0};
    int err = llist_fetch(head,&id3,id_cmp,&temp);
    if(err != 0)
        printf("没有找到\r\n");
    else
    {
        printf("name : %s\r\n",temp.name);
        printf("age : %d\r\n",temp.age);
        printf("id : %d\r\n",temp.id);
    }

    err = llist_find(head,&id,id_cmp,&temp);
    if(err != 0)
        printf("没有找到\r\n");
    else
    {
        printf("name : %s\r\n",temp.name);
        printf("age : %d\r\n",temp.age);
        printf("id : %d\r\n",temp.id);
    }

    llist_show(head,student_print);

    llist_destroy(head);
    exit(0);
}
你好啊陈同学
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构以及应用算法教程参考答案（2）第二章答案下
VAN
04-01 1407
2.26 要求同2.25题。试对单链表编写求C的算法。 　　解： // 将A、B求交后的结果放在C表中，并删除B表 Status ListCross_L(LinkList &A,LinkList &B,LinkList &C) { LinkList pa,pb,qa,qb,pt; pa=A; pb=B; qa=pa; // 保存pa的前驱指针 qb=pb; // 保存pb的前驱指针 pa=pa->next; pb=pb->next; C=A; while(pa&&
C语言实现数据结构：单链表，循环链表，双向链表；静态顺序队列
最新发布
10-19
C语言实现数据结构：单链表，循环链表，双向链表；静态顺序队列，动态顺序队列，链式队列；静态顺序栈，动态顺序栈，链式栈；二叉树，线索二叉树；排序算
C语言数据结构之双向循环链表的实例
08-30
主要介绍了C语言数据结构之双向循环链表的实例的相关资料,需要的朋友可以参考下
数据结构第二章线性表算法设计练习题（C语言）
weixin_45627194的博客
12-13 940
2．算法设计题 （1）将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中不允许有重复的数据。 （2）将两个非递减的有序链表合并为一个非递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中允许有重复的数据。 （3）已知两个链表A和B分别表示两个集合，其元素递增排列。请设计算法求出A与B的交集，并存放于A链表中。
数据结构线性表课后习题（数据结构考试重点）
kaakllhjkhjalv的博客
07-08 1万+
1. 简述线性表两种存储结构各自的主要特点。 答：线性表的两种存储结构分别是顺序存储结构和链式存储结构。顺序存储结构的主 要特点如下： ① 数据元素中只有自身的数据域，没有关联指针域。因此，顺序存储结构的存储密度 较大。 ② 顺序存储结构需要分配一整块比较大存储空间，所以存储空间利用率较低。 ③ 逻辑上相邻的两个元素在物理上也是相邻的，通过元素的逻辑序号可以直接其元素 值，即具有随机存取特性。 ④ 插入和删除操作会引起大量元素的移动。 链式存储结构的主要特点如下： ① 数据结点中除自身的数据域，还有表示逻辑
关于链表的算法题
weixin_46390041的博客
03-10 1203
1、题目：已知 p 指向双向循环链表中的一个结点，其结点结构为 data、llink、rlink 三个域， 写出算法 change(p),交换 p 所指向的结点和它的前驱结点的顺序。 思路：假设p所指向的结点的前驱结点q，首先应该把q的地址找到，一共要移动六个指针，有7条语句，6条是要移动的，先连后改，改的时候也是要先指向，后改（先下后上），最后三步不能改变顺序。 void Exchange (LinkedList p){ // P是双向循环链表中的一个结点，本算法将p所指结点与其前驱结点交换
已知p指向双向循环链表中的一个结点，交换所指向的结点及其前驱结点的顺序。
weixin_69200869的博客
10-14 2002
已知p指向双向循环链表中的一个结点，其结点结构（data，prior，next），写出算法Exchange（p），交换所指向的结点及其前驱结点的顺序。编写程序测试Exchange函数。
数据结构(C语言第2版) 课后习题答案之第二章 线性表
Yummy的博客
04-12 1万+
目录 第二章 线性表 1．选择题 （1）一个向量第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（ ）。 （2）在n个结点的顺序表中，算法的时间复杂度是O(1)的操作是（ ）。 （3）向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动的元素个数为（ ）。 （4）链接存储的存储结构所占存储空间（ ）。 （5）线性表若采用链式存储结构时，要求内存中可用存储单元的地址（ ）。 （6）线性表Ｌ在（ ）情况下适用于使用链式结构...
【数据结构与算法】——第二章：线性表
cqy阳的博客
06-30 405
【数据结构与算法】——第二章：线性表
第二章算法设计题9
weixin_48192326的博客
11-10 1770
第二章算法设计题9 题目描述 已知p指向双向循环链表中的一个结点，其结点结构为data、prior、next三个域，写出算法change(p),交换p所指向的结点及其前驱结点的顺序。 求解思路 代码实现 #pragma once #include <iostream> #include<string> using namespace std; //双链表的存储结构 typedef struct DuLnode { //数据域 int data; //指向直接前驱
10.15 - 每日一题 - 408
yanlei233的博客
10-15 251
每日一句：努力和收获，都是自己的，与他人无关。最大的成就感，就是一直在朝着自己想要的方向前进。 数据结构 1．在非空双向循环链表中q所指的链接点前面插入一个由p指的链接点的过程是依次执行语句p->rlink=q；p->llink=q->llink；q->llink=p； 。（北京航空航天大学 2007年） A．q->rlink->llink=p； B．q->llink->rlink=p； C．p->rlink->llink=p； D
数据结构8: 双向链表(双向循环链表)的建立及C语言实现
weixin_30951389的博客
05-12 305
之前接触到的链表都只有一个指针，指向直接后继，整个链表只能单方向从表头访问到表尾，这种结构的链表统称为“单向链表”或“单链表”。 如果算法中需要频繁地找某结点的前趋结点，单链表的解决方式是遍历整个链表，增加算法的时间复杂度，影响整体效率。为了快速便捷地解决这类问题，在单向链表的基础上，给各个结点额外配备一个指针变量，用于指向每个结点的直接前趋元素。这样的链表被称为“双向链表”或者“双链表”。 ...
C语言演示链表操作.rar_C语言_双向循环链表_数据结构_链表 list_链表操作
09-19
数据结构的链表关系，用TC2.0 编写，比较完整，可以作为学生的教学用
双向链表API及C语言实现
03-29
双向链表的API和C语言...另外还有线性表顺序存储、单链表、循环链表的C语言实现，文章及代码资源均已上传，可在专栏《数据结构与算法学习笔记》中查看，欢迎大家查看下载，如果内容有不合理的地方，欢迎大家批评指正。
数据结构与算法 试题与答案
热门推荐
wu_lai_314的专栏
11-21 4万+
一、判断题： 1、线性表的逻辑顺序与物理顺序总是一致的。(   ) 2、线性表的顺序存储表示优于链式存储表示。(   ) 3、线性表若采用链式存储表示时所有结点之间的存储单元地址可连续可不连续。(   ) 4、二维数组是其数组元素为线性表的线性表。(   ) 5、每种数据结构都应具备三种基本运算：插入、删除和搜索。(     ) 6、数据结构概念包括数据之间的逻辑结构，数据在计算机中的
【吉大刘大有数据结构绿皮书】例3.16：已知非空线性链表第一个结点的指针为list，写一算法，删除线性链表中的第i个结点。
随手写写
09-13 1024
已知非空线性链表第一个结点的指针为list，写一算法，删除线性链表中的第i个结点。
一套代码在不同的电脑执行快慢_图解：链表的快慢指针，解决面试中的链表题！...
weixin_39688451的博客
12-03 150
一、前言链表是基本的数据结构之一，它与数组不同，数组在内存中存储，需要一块连续的内容空间来存储，对内存的要求比较高。例如我们需要 100MB 大小的数组，内存中就必须有一段连续的 100MB 的内存空间，否则就会出现 OOM。而链表则不同，链表不需要一块连续的内存空间。它是通过“指针”，将一组零散的内存块串联起来。所以完全不用担心连续内存空间以及扩容等问题。数据结构中的链表，一直是面试的常客，尤其...
c语言数据结构线性链表的结点移动
m0_74297053的博客
10-15 448
请写一算法，将该链表中数据域值最大的那个点移到链表的最后面。（假设链表中数据域值最大的链结点惟一）（注意：要求先写出算法的解题思路，然后再写出算法）输入为一个整数序列，整数之间以空格隔开，序列以回车结尾，输入-1结束（假设链表中吴数据-1）。输出为移动后的整数序列，整数之间以空格隔开，序列以回车结尾。已知非空线性链表第1个链结点指针为list，链结点构造为。
数据结构之线性结构--双向循环链表
无_空
10-08 2925
一、双向循环链表特点双向循环链表的结构是在双向链表的基础上使头节点的前驱指针指向末尾的节点，而使末尾的节点的一个指针指向开始节点，形成一个循环结构。 双向循环链表在进行节点的删除的时候的操作： 双向循环链表在进行节点的插入时的操作： 二、双向循环链表的实现AL_Node.h文件#ifndef AL_NODE_INCLUDE #define AL_NODE_INCLUDE#include
C语言数据结构双向循环链表
09-27
在C语言中，实现双向循环链表需要定义一个链表节点结构体，其中包含指向前驱节点和后继节点的指针，以及存储数据的成员。以下是一个示例的C语言代码来初始化一个双向循环链表： ``` typedef int LTDataType; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值