双向循环链表

最新推荐文章于 2024-11-08 11:30:25 发布
最新推荐文章于 2024-11-08 11:30:25 发布
阅读量176 收藏
点赞数
分类专栏： C语言 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nichun12345/article/details/121061405
版权

前言
适用性较广的双向环链。实现比较困难，主要看看怎么使用。
代码的使用方法：

  1. 移植llist.h和llist.c文件
  2. 定义适合自己的结构体类型，比如
struct score_st  //用户的数据
{
    int id;
    char name[NAMESIZE];
    int math;
    int chinese;
};
  1. 自定义一个打印函数，如：
    printf()括号里面根据实际情况修改。
static void print_s(const void *record)
{
    const struct score_st *r = record;//类型转换
    printf("%d %s %d %d\n",r->id,r->name,r->math,r->chinese);  //改这里
}
  1. 自定义按某个关键字查找的函数，如按id查找
static int id_cmp(const void *key,const void *record)
{
    const int *k = key;  //类型转换
    const struct score_st *r = record; //改成你的结构体(score_st)
    return (*k - r->id);               //改这里
}

示例代码1
main.c文件

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

#define NAMESIZE    32

//用户的数据
struct score_st
{
    int id;
    char name[NAMESIZE];
    int math;
    int chinese;
};
/*函数声明*/
static void print_s(const void *record);
static int id_cmp(const void *key,const void *record);
static int name_cmp(const void *key,const void *record);

int main()
{
    int i,ret;
    struct score_st tmp;//定义用户数据的结构体
    LLIST *handler;     //定义头指针
	//创建链表时指定结构体的大小
    handler = llist_create(sizeof(struct score_st));
    for(i=0;i<7;i++)  //循环插入数据
    {
        tmp.id = i;
        snprintf(tmp.name,NAMESIZE,"std%d",i);
        tmp.math = rand()%100;
        tmp.chinese = rand()%100;
        //ret = llist_insert(handler,&tmp,LLIST_FORWARD);  //首部插入
        ret = llist_insert(handler,&tmp,LLIST_BACKWARD);  //尾部插入
        if(ret)     exit(1);
    }

    llist_travel(handler,print_s);  //遍历链表

    printf("\n\n");

    int id = 3;
    struct sroce *data;
    data = llist_find(handler,&id,id_cmp);

    if(data==NULL)
    {
        printf("找不到\n");
    }
    else
    {
        print_s(data);
    }
    
    printf("\n\n");
    
    char *del_name = "std6";
    //ret = llist_delete(handler,&id,id_cmp);
    ret = llist_delete(handler,del_name,name_cmp);
    if(ret)
    {
        printf("delete失败\n");
    }
    llist_travel(handler,print_s);

    llist_destroy(handler);

    return 0;
}

/*函数实现*/
//自定义的打印函数：
static void print_s(const void *record)
{
    const struct score_st *r = record;//类型转换
    printf("%d %s %d %d\n",r->id,r->name,r->math,r->chinese);
}
//用户定义的按id查找的函数
static int id_cmp(const void *key,const void *record)
{
    const int *k = key;  //类型转换
    const struct score_st *r = record;
    return (*k - r->id);
}
//用户定义的按名字查找的函数
static int name_cmp(const void *key,const void *record)
{
    const char *k = key;
    const struct score_st *r = record;
    return strcmp(k,r->name);
}

llist.h文件

#ifndef     LLIST_H__
#define     LLIST_H__
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define LLIST_FORWARD   1
#define LLIST_BACKWARD  2

//重定义函数类型
typedef void llist_op(const void *);//
typedef int llist_cmp(const void *,const void *);

//有效节点的结构体,变长结构体
struct llist_node_st
{
    //void *data;  //数据域
    struct llist_node_st *prev;
    struct llist_node_st *next;
    char data[0];//数组名是地址，c99支持[0]
};
//头节点的结构体
typedef struct
{
    int size;
    struct llist_node_st head;
}LLIST;

//函数声明部分
LLIST *llist_create(int initsize);
int llist_insert(LLIST *,const void *data,int mode);
void *llist_find(LLIST *,const void *key,llist_cmp *);
int llist_delete(LLIST *, const void *key,llist_cmp *);
int llist_fetch(LLIST *,const void *key,llist_cmp *,void *data);
void llist_travel(LLIST *,llist_op *);
void llist_destroy(LLIST *);

#endif

llist.c文件

#include "llist.h"

//创建只包含头节点的空双向环链
LLIST *llist_create(int initsize)
{
    LLIST *new;
    new = malloc(sizeof(*new));
    if(new==NULL)   return NULL;

    new->size = initsize;         //用户数据的大小
    new->head.prev = &new->head;  //形成环
    new->head.next = &new->head;

    return new;              //返回头指针
}
/*
   断2个，连4个
   若已知插入的前驱节点p
   q->prev = p;       //确定插入节点q的前驱
   q->next = p->next  //确定插入节点q的后继
   q->prev->next = q; //断开q的前驱和后继的连接
   q->next->prev = q;  //断开q的前驱和后继的连接

   若已知插入节点的后继节点p
   q->next = p;
   q->prev = p->prev;
   q->prev->next = q;
   q->next->prev = q;
   */
//节点的插入
int llist_insert(LLIST *ptr,const void *data,int mode)
{
    struct llist_node_st *newnode;
    //申请足够大的内存空间
    newnode = malloc(sizeof(*newnode)+ptr->size);
    if(newnode==NULL)   return -1;

    //内存拷贝
    memcpy(newnode->data,data,ptr->size);
    //首部插入,已知插入的前驱
    if(mode == LLIST_FORWARD)
    {
        newnode->prev = &ptr->head;
        newnode->next = ptr->head.next;
    }
    //尾部插入,已知插入的后继
    else if(mode == LLIST_BACKWARD)
    {
        newnode->prev = ptr->head.prev;
        newnode->next = &ptr->head;
    }
    else
    {
        return -3;
    }
    newnode->prev->next = newnode;
    newnode->next->prev = newnode;
    return 0;
}

//在链表ptr中寻找*key,找的方式是cmp
static struct llist_node_st *find_(LLIST *ptr,const void *key,llist_cmp *cmp)
{
    struct llist_node_st *cur;
    for(cur=ptr->head.next;cur!=&ptr->head;cur=cur->next)
    {
        //找到时，cmp()返回0
        if(cmp(key,cur->data)== 0)  break;
    }
    return cur;  //返回当前节点
}

void *llist_find(LLIST *ptr,const void *key,llist_cmp *cmp)
{
    struct llist_node_st *node;

    node = find_(ptr,key,cmp);
    if(node == &ptr->head)  return NULL;
    return node->data;
}
//删除节点：在ptr指向的链表里寻找key,寻找的方式是 cmp
int llist_delete(LLIST *ptr, const void *key,llist_cmp *cmp)
{
    struct llist_node_st *node;
    node = find_(ptr,key,cmp);
    // 不删头节点
    if(node==&ptr->head)        return -1;

    //删除node 节点
    node->prev->next = node->next;
    node->next->prev = node->prev;
    free(node);
    return 0;
}
//拿出节点：在ptr指向的链表里寻找key,寻找的方式是 cmp，返回拿出的数据
int llist_fetch(LLIST *ptr,const void *key,llist_cmp *cmp,void *data)
{
    struct llist_node_st *node;
    node = find_(ptr,key,cmp);
    if(node==&ptr->head)    return -1;

    node->prev->next = node->next;
    node->next->prev = node->prev;

    if(data!=NULL)
    {
        memcpy(data,node->data,ptr->size);
    }

    free(node);
    return 0;
}

//遍历链表：在ptr指向的链表里以op的方式遍历
void llist_travel(LLIST *ptr,llist_op *op)
{
    struct llist_node_st *cur,*next;
    //cur指向第1个有效节点;cur不指向头节点;cur不停往后指向
    for(cur=ptr->head.next;cur!=&ptr->head;cur=cur->next)
    {
        op(cur->data);      //回调函数  
    }
}

//销毁链表
void llist_destroy(LLIST *ptr)
{
    struct llist_node_st *cur,*next;

    //让cur指向第1个有效节点;头节点在循环不删;cur不停地向后移动
    for(cur=ptr->head.next;cur!=&ptr->head;cur=next)
    {
        next = cur->next; //保存当前节点的下一节点
        free(cur);  //销毁当前节点
    }
    free(ptr);  //销毁头节点
}

运行结果
在这里插入图片描述

示例代码2
简单应用
main.c文件

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

#define NAMESIZE    32
struct student_st
{
    char name[NAMESIZE];
    int height;
    int weight;
};

static void print_s(const void *record);

int main()
{
    int i,ret;
    struct student_st tmp;
    LLIST *handler;
    handler = llist_create(sizeof(struct student_st));
    printf("分别输入姓名 身高 体重：\n");
    for(i=0;i<3;i++)
    {   
        scanf("%s%d%d",tmp.name,&tmp.height,&tmp.weight);
        llist_insert(handler,&tmp,LLIST_FORWARD);  //首部插入
        if(ret) exit(1);
    }   

    printf("打印结果\n");
    llist_travel(handler,print_s);  
    llist_destroy(handler);

    return 0;
}

//用户根据实际情况自定义的打印函数
static void print_s(const void *record)
{
    const struct student_st *r = record;//类型转换
	printf("%s %d %d\n",r->name,r->height,r->weight);
}

运行结果
在这里插入图片描述

⁽⁽ଘ晴空万里ଓ⁾⁾
关注
专栏目录
双向环形链表实现
Sunhongzhe的博客
01-09 291
实现类： package demo03_LinkedList; import java.util.Iterator; /** * @program: dataStructures_algorithms * @description: 双向环形链表 * @author: Sun * @create: 2020/01/09 09:15 * @version: 1.0 */ public...
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
数据结构-5-160809双向有头环链
小雨的博客
08-09 455
太没用了，暗自捶胸，代码写完 老多错误了，信心都没了，╮(╯▽╰)╭ 目前好歹实现了 ， 有兴趣的凑合看下吧 ======================主函数==================================== #include #include #include"list.h" #define SIZE 32 typedef struct _score_
用c语言创建双向环形链表
weixin_30263277的博客
11-18 191
作为一个C开发人员，无论在求职笔试题中，还是在工程项目中，都会遇到用c语言创建双向环形链表。这个也是理解和使用c指针的一项基本功。 #include<...>//头文件省略 typedef struct ringbuf_str{ unsigned int ringID; /* ring ID*/ struct ringbuf_str *next; /* Next ring...
双向循环链表的实现
strokeyang
11-22 3015
   最近将一个开源项目port到嵌入式设备上，发现其巨大部分类都是继承于双向链表（或者双向队列），这一个过程看似不可思议（感觉有违我们以前学的面向对象的知识），但是事实却是这样的方式使很多操作都变得简单起来，由于类继承于Link，则在Link类中不需要用特定的变量指向特定的数据，而这一过程在使用这个类的时候已近默认的实现。以前读本科的时候，也只是了解到了双向循环链表的理论，没有实现，今天乘这个机
数据结构学习之双向循环链表操作
CHNIM的博客
07-03 643
链表头文件 #ifndef _LIST_H_ #define _LIST_H_ #include #include typedef struct _list { int m_data; struct _list * next; struct _list * prev; }list,*node; void listCreate(list * t_list); void listHe
Linux操作系统中通用双向循环链表的实现分析.pdf
09-06
Linux操作系统中通用双向循环链表的实现分析 Linux操作系统是一个支持多用户、多任务、多线程和多CPU的开源操作系统，其内核功能强大、性能稳定并具有丰富的应用软件支持。Linux内核源代码主要由C语言和少量的汇编...
C语言中双向链表和双向循环链表详解
08-30
C语言中双向链表和双向循环链表详解 本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言...
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
C语言双向循环链表的相关操作
qq_54075859的博客
08-24 366
C语言双向循环链表的相关操作：1.结构体设置 2.双向循环链表初始化 3.头插 4.遍历 5.尾插 6.删除某个数据 7.查询某个数据的位置 8.修改某个数据为新的数据 9.奇升偶降
【数据结构】双向带头循环链表
l1547133114的博客
05-11 120
数据结构——双向带头循环链表
HashMap中扩容导致环链现象分析
jarniyy的博客
05-02 1208
目录 为什么会出现环链？ 什么时候会出现环链？ 出现环链的场景：       数据准备、结果预期       模拟的转移代码   多线程的场景分析  形成的根本原因 数据分析 线程一数据变化 第一次循环  第二次循环 线程二开始执行 为什么会出现环链？       &...
数据结构---详解单链表
最新发布
weixin_63997543的博客
11-08 225
详解单链表
【新人系列】Python 入门（八）：数据结构 - 上
Newin2020的博客
11-08 911
创建列表使用 [ ] 直接创建列表其中，listname 表示变量名，element1 ~ elementn 表示列表元素。使用 list( ) 函数创建列表除了使用 [ ] 创建列表外，Python 还提供了一个内置的函数 list( )，使用它可以将其它数据类型转换为列表类型。# 将字符串转换成列表# 将元组转换成列表。
数据结构之——堆
m0_71974552的博客
11-08 441
堆可以被看作是一棵树的数组对象。在存储结构上，堆与普通树有一些区别。普通树的存储方式可以有多种，如链式存储、数组存储等。而堆通常采用数组来存储完全二叉树，这样可以利用数组的索引关系快速定位节点的父子关系。孩子兄弟表示法是一种表示树结构的方式。在这种表示法中，每个节点有两个指针，分别指向其第一个孩子节点和下一个兄弟节点。相比之下，堆采用数组存储时，通过特定的索引计算可以快速找到节点的父子关系。
python之数据结构与算法（数据结构篇）-- 队列
2301_81807150的博客
11-05 235
【代码】python之数据结构与算法（数据结构篇）-- 队列。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

⁽⁽ଘ晴空万里ଓ⁾⁾

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

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

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

打赏作者

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

抵扣说明：

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

余额充值