一个通用链表模块（C语言）

最新推荐文章于 2024-01-21 21:15:12 发布
最新推荐文章于 2024-01-21 21:15:12 发布
阅读量1.1k 收藏
点赞数
分类专栏： 嵌入式开发 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CodeHeng/article/details/51939630
版权

1）把所有DBG和ERR改成printf；
2）COMMOM_Malloc改成malloc；
3）COMMON_Free改成free；
4）所有的CHECK写一个空的宏即可(原来作为参数合法性检查)；
5）编译Ok；

#ifndef __LIST_H__
#define __LIST_H__

#ifdef __cplusplus
#if __cplusplus
extern "C"{
#endif
#endif


typedef void* LIST_HANDLE;

LIST_HANDLE LIST_Init(int _s32NodeDataSize);
int LIST_Destroy(LIST_HANDLE _hndList);
int LIST_AddToHead(LIST_HANDLE _hndList, void* _pData, int _s32DataSize);
int LIST_AddToTail(LIST_HANDLE _hndList, void* _pData, int _s32DataSize);
int LIST_Delete(LIST_HANDLE _hndList, void* pData);
int LIST_DeleteHead(LIST_HANDLE _hndList);
int LIST_DeleteTail(LIST_HANDLE _hndList);
int LIST_Clear(LIST_HANDLE _hndList);
int LIST_GetCnt(LIST_HANDLE _hndList);
void* LIST_GetHead(LIST_HANDLE _hndList);
void* LIST_GetTail(LIST_HANDLE _hndList);
void* LIST_GetNextNode(LIST_HANDLE _hndList, void* pData);
void* LIST_GetPrevNode(LIST_HANDLE _hndList, void* pData);
int LIST_IsEmpty(LIST_HANDLE _hndList);


#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif

#endif


#include "list.h"
#include "debug.h"
#include "common.h"

#define LIST_MAGIC_NUM 0xabcd0000

typedef struct LIST_NODE_S
{
    void* pData;
    struct LIST_NODE_S* pstNext;
    struct LIST_NODE_S* pstPrev;
}LIST_NODE_S;

typedef struct LIST_S
{
    unsigned int u32MagicNumer;
    int s32Cnt; // node numbers of list
    int s32NodeDataSize; // node size

    LIST_NODE_S* pstHead;
    LIST_NODE_S* pstTail;
}LIST_S;

static LIST_NODE_S* LIST_LookUp(LIST_HANDLE _hndList, void* pData)
{
    LIST_S* pstList = (LIST_S*)_hndList;
    LIST_NODE_S* tmp = pstList->pstHead;
    while (NULL != tmp)
    {
        if (tmp->pData == pData)
        {
            return tmp;
        }
        tmp = tmp->pstNext;
    }
    ERR("the node is not exist.\n");

    return NULL;
}

LIST_HANDLE LIST_Init(int s32NodeDataSize)
{
    CHECK(s32NodeDataSize > 0, NULL, "invalid parameter.\n");

    LIST_S* pstList = (LIST_S*)COMMON_Malloc(sizeof(LIST_S));
    CHECK(NULL != pstList, NULL, "failed to malloc %d\n", sizeof(LIST_S));

    memset(pstList, 0, sizeof(LIST_S));
    pstList->s32NodeDataSize = s32NodeDataSize;
    pstList->s32Cnt = 0;
    pstList->pstHead = NULL;
    pstList->pstTail = NULL;
    pstList->u32MagicNumer = LIST_MAGIC_NUM;

    return (LIST_HANDLE)pstList;
}

int LIST_Destroy(LIST_HANDLE _hndList)
{
    CHECK(NULL != _hndList, -1, "invalid parameter.\n");

    int ret = -1;
    ret = LIST_Clear(_hndList);
    CHECK(!ret, ret, "error: ret is %d\n", ret);

    ret = COMMON_Free(_hndList);
    CHECK(!ret, ret, "error: ret is %d\n", ret);

    return ret;
}

int LIST_AddToHead(LIST_HANDLE _hndList, void* pData, int DataSize)
{
    CHECK(NULL != _hndList, -1, "invalid parameter.\n");
    CHECK(NULL != pData, -1, "invalid parameter.\n");

    LIST_S* pstList = (LIST_S*)_hndList;
    CHECK(pstList->s32NodeDataSize == DataSize, -1, "invalid parameter.\n");

    LIST_NODE_S* pstNewNode = (LIST_NODE_S*)COMMON_Malloc(sizeof(LIST_NODE_S) + pstList->s32NodeDataSize);
    CHECK(NULL != pstNewNode, -1, "failed to malloc %d\n", sizeof(LIST_NODE_S) + pstList->s32NodeDataSize);

    memset(pstNewNode, 0, sizeof(LIST_NODE_S) + pstList->s32NodeDataSize);
    pstNewNode->pData = (void*)(pstNewNode+1);
    memcpy(pstNewNode->pData, pData, pstList->s32NodeDataSize);
    if (NULL == pstList->pstTail && NULL == pstList->pstHead)
    {
        pstList->pstHead = pstNewNode;
        pstList->pstTail = pstNewNode;
        pstNewNode->pstNext = NULL;
        pstNewNode->pstPrev = NULL;
    }
    else
    {
        pstList->pstHead->pstPrev = pstNewNode;
        pstNewNode->pstNext = pstList->pstHead;
        pstList->pstHead = pstNewNode;
        pstNewNode->pstPrev = NULL;
    }
    pstList->s32Cnt++;

    return 0;
}

int LIST_AddToTail(LIST_HANDLE _hndList, void* pData, int DataSize)
{
    CHECK(NULL != _hndList, -1, "invalid parameter.\n");
    CHECK(NULL != pData, -1, "invalid parameter.\n");

    LIST_S* pstList = (LIST_S*)_hndList;
    CHECK(pstList->s32NodeDataSize == DataSize, -1, "invalid parameter.\n");

    LIST_NODE_S* pstNewNode = (LIST_NODE_S*)COMMON_Malloc(sizeof(LIST_NODE_S) + pstList->s32NodeDataSize);
    CHECK(NULL != pstNewNode, -1, "failed to malloc %d\n", sizeof(LIST_NODE_S) + pstList->s32NodeDataSize);

    memset(pstNewNode, 0, sizeof(LIST_NODE_S) + pstList->s32NodeDataSize);
    pstNewNode->pData = (void*)(pstNewNode+1);
    memcpy(pstNewNode->pData, pData, pstList->s32NodeDataSize);
    if (NULL == pstList->pstTail && NULL == pstList->pstHead)
    {
        pstList->pstHead = pstNewNode;
        pstList->pstTail = pstNewNode;
        pstNewNode->pstNext = NULL;
        pstNewNode->pstPrev = NULL;
    }
    else
    {
        pstList->pstTail->pstNext = pstNewNode;
        pstNewNode->pstPrev = pstList->pstTail;
        pstList->pstTail = pstNewNode;
        pstNewNode->pstNext = NULL;
    }
    pstList->s32Cnt++;

    return 0;
}

int LIST_Delete(LIST_HANDLE _hndList, void* pData)
{
    CHECK(NULL != _hndList, -1, "invalid parameter.\n");
    CHECK(NULL != pData, -1, "invalid parameter.\n");

    int ret = -1;
    LIST_S* pstList = (LIST_S*)_hndList;
    LIST_NODE_S* pstFind = LIST_LookUp(pstList, pData);
    if (NULL != pstFind)
    {
        if (pstList->s32Cnt == 1)
        {
            pstList->pstHead = NULL;
            pstList->pstTail = NULL;
        }
        else
        {
            if (pstFind == pstList->pstHead)
            {
                pstList->pstHead->pstNext->pstPrev = NULL;
                pstList->pstHead = pstList->pstHead->pstNext;
            }
            else if (pstFind == pstList->pstTail)
            {
                pstList->pstTail->pstPrev->pstNext = NULL;
                pstList->pstTail = pstList->pstTail->pstPrev;
            }
            else
            {
                pstFind->pstPrev->pstNext = pstFind->pstNext;
                pstFind->pstNext->pstPrev = pstFind->pstPrev;
            }
        }

        ret = COMMON_Free(pstFind);
        CHECK(!ret, ret, "error: ret is %d\n", ret);

        pstList->s32Cnt--;
    }

    return ret;
}

int LIST_DeleteHead(LIST_HANDLE _hndList)
{
    CHECK(NULL != _hndList, -1, "invalid parameter.\n");

    int ret = -1;
    LIST_S* pstList = (LIST_S*)_hndList;
    if (NULL != pstList->pstHead)
    {
        if (pstList->s32Cnt == 1) // only one node
        {
            ret = COMMON_Free(pstList->pstHead);
            CHECK(!ret, ret, "error: ret is %d\n", ret);

            pstList->pstHead = NULL;
            pstList->pstTail = NULL;
        }
        else
        {
            LIST_NODE_S* tmp = pstList->pstHead;
            pstList->pstHead->pstNext->pstPrev = NULL;
            pstList->pstHead = pstList->pstHead->pstNext;

            ret = COMMON_Free(tmp);
            CHECK(!ret, ret, "error: ret is %d\n", ret);
        }
        pstList->s32Cnt--;
        //DBG("delete head node success.list size: %d\n", pstList->s32Cnt);
    }

    return ret;
}

int LIST_DeleteTail(LIST_HANDLE _hndList)
{
    CHECK(NULL != _hndList, -1, "invalid parameter.\n");

    int ret = -1;
    LIST_S* pstList = (LIST_S*)_hndList;
    if (NULL != pstList->pstTail)
    {
        if (pstList->s32Cnt == 1) // only one node
        {
            ret = COMMON_Free(pstList->pstTail);
            CHECK(!ret, ret, "error: ret is %d\n", ret);

            pstList->pstHead = NULL;
            pstList->pstTail = NULL;
        }
        else
        {
            LIST_NODE_S* tmp = pstList->pstTail;
            pstList->pstTail->pstPrev->pstNext = NULL;
            pstList->pstTail = pstList->pstTail->pstPrev;

            ret = COMMON_Free(tmp);
            CHECK(!ret, ret, "error: ret is %d\n", ret);
        }
        pstList->s32Cnt--;
        //DBG("delete tail node success.list size: %d\n", pstList->s32Cnt);
    }

    return ret;
}

int LIST_Clear(LIST_HANDLE _hndList)
{
    CHECK(NULL != _hndList, -1, "invalid parameter.\n");

    int ret = -1;
    while (LIST_GetCnt(_hndList) > 0)
    {
        ret = LIST_DeleteTail(_hndList);
        CHECK(!ret, ret, "error: ret is %d\n", ret);
    }

    return ret;
}

int LIST_GetCnt(LIST_HANDLE _hndList)
{
    CHECK(NULL != _hndList, -1, "invalid parameter.\n");

    LIST_S* pstList = (LIST_S*)_hndList;

    return pstList->s32Cnt;
}

void* LIST_GetHead(LIST_HANDLE _hndList)
{
    CHECK(NULL != _hndList, NULL, "invalid parameter.\n");

    LIST_S* pstList = (LIST_S*)_hndList;

    return (pstList->pstHead) ? pstList->pstHead->pData : NULL;
}

void* LIST_GetTail(LIST_HANDLE _hndList)
{
    CHECK(NULL != _hndList, NULL, "invalid parameter.\n");

    LIST_S* pstList = (LIST_S*)_hndList;

    return (pstList->pstTail) ? pstList->pstTail->pData : NULL;
}

int LIST_IsEmpty(LIST_HANDLE _hndList)
{
    CHECK(NULL != _hndList, -1, "invalid parameter.\n");

    LIST_S* pstList = (LIST_S*)_hndList;

    return (pstList->s32Cnt == 0);
}

void* LIST_GetNextNode(LIST_HANDLE _hndList, void* pData)
{
    CHECK(NULL != _hndList, NULL, "invalid parameter.\n");
    CHECK(NULL != pData, NULL, "invalid parameter.\n");

    LIST_NODE_S* pstFind = LIST_LookUp(_hndList, pData);
    if (NULL != pstFind && NULL != pstFind->pstNext)
    {
        return pstFind->pstNext->pData;
    }

    return NULL;
}

void* LIST_GetPrevNode(LIST_HANDLE _hndList, void* pData)
{
    CHECK(NULL != _hndList, NULL, "invalid parameter.\n");
    CHECK(NULL != pData, NULL, "invalid parameter.\n");

    LIST_NODE_S* pstFind = LIST_LookUp(_hndList, pData);
    if (NULL != pstFind && NULL != pstFind->pstPrev)
    {
        return pstFind->pstPrev->pData;
    }

    return NULL;
}
CodeHeng
关注
专栏目录
C语言—通用链表
别呀的博客
03-28 1766
思考：当一个项目里要使用多种结构体类型的链表，例如点菜系统里有人员、菜谱两种结构体，若要对这两种链表操作，就需要编写2套链表操作代码，对链表的操作有链表创建、添加节点、删除节点、获取链表节点个数、获取链表结点数据、释放链表等，这就会花费我们大量的时间。对于这2种业务，对链表的操作是相同的，那能不能编写一套通用的链表操作函数，这2种应用只要调用相应的操作函数即可？面临这样的问题，所以有了通用链表。 这里写目录标题通用链表设计通用链表基本操作通用链表示例 通用链表设计 通用链表结构体： struct lis.
C语言通用链表
weixin_46146281的博客
04-16 229
通用链表把初始化分为两部分，指针域和数据域分开初始化，大大提高了通用性，用户可以根据自己的业务需求创建业务数据域。通用链表数据块是由list成员串联起来的，它的next和prev指向的是业务数据结构体中list成员的首地址，所以。需要根据list成员的首地址得到业务数据结构体的首地址，才能进行访问其它成员的数据。单纯的通用链表是没有意义的，要结合业务类型。通过结构体成员获取结构体首地址宏定义。
通用链表（C语言实现）
weixin_43504629的博客
07-13 798
#include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include "list.h" //设计链表节点 typedef struct Node { void* ptr; //指向数据的首地址 struct Node* next; // 元素的下一个位置 }Node; /...
C语言实现通用链表
菜鸟攻城狮
10-19 1056
C语言实现通用链表
C语言的通用链表
西风世界
04-11 4738
在操作系统编程中， 往往是使用C语言， 但C使用起来极为痛苦， 不像C++有方便的STL模板库使用。linux内核中，有一套非常神奇的通用链表结构，能够方便的使用，管理各种类型的数据，我们今天就来研究一下，内核中的C数据结构。
c语言数据结构之通用链表
xingweiyong的专栏
11-12 990
这篇文章对链表这种数据结构进行深入分析和改造，常规的链表数据域的数据类型都是固定的，借助void*通用指针可以实现通用型的链表，链表的数据域是可以存放任何数据类型，而不必每次都将数据类型固定下来，但是要求链表的数据要一致，不能同时存储多种数据类型。这篇文章是学习了一篇微信公众号文章，对其中的代码进行复现，文末会贴出该公众号的链接，并表示对作者的感谢和敬佩！ 首先构造链表节点数据类型，每一个节点包含
OrderDish点菜系统 c语言实现用c语言实现简单的菜馆点才系统，包含通用链表以及各个模块.zip
最新发布
06-27
总的来说，OrderDish点菜系统是一个很好的学习案例，它展示了C语言如何结合通用链表解决实际问题，同时也是一个了解和提升C语言编程技巧的好途径。通过深入理解和实践这样的项目，开发者可以增强对数据结构的理解，...
循环链表C语言源文件及程序
10-15
然而，在循环链表中，最后一个节点的指针并不指向空，而是指向链表的第一个节点，形成一个闭环。这种设计使得链表在遍历和某些特定操作（如循环遍历）时更为便捷。 在这个项目中，我们有两个关键的源文件——`...
一个通用的C语言编写的类似STL功能的集合库，实现比较简单，通用性比较强.zip
06-14
标题中提到的"一个通用的C语言编写的类似STL功能的集合库"，是针对C语言的一个扩展，它尝试模仿STL的模式，为C程序员提供了一套容器和算法的实现。这样的库对于初学者来说是非常有价值的，因为它不仅能够帮助他们...
c语言通用链表库
02-02
本代码提供采用c语言编写链表的使用源码，有创建、初始化、删除、插入、查找等等功能
纯C语言实现的通用链表（类）源代码
01-14
纯C语言实现的通用链表（类）源代码，可以供学习参考，内附代码，可执行
c语言做的一个任务管理（C语言课程设计）.rar
08-11
在本项目中，我们关注的是一个使用C语言编写的任务管理器。C语言是一种底层、通用的编程语言，因其高效性和灵活性而广泛用于系统编程、软件开发以及各种嵌入式系统。这个任务管理器可以看作是C语言课程设计的一个...
C学生管理系统通用链表
04-26
【C学生管理系统通用链表】是一个使用C语言编写的程序，它在Linux环境下运行，主要目的是管理和操作学生信息。这个系统的核心数据结构是通用链表，它可以存储不同类型的数据，如学生、教师和管理员的信息。链表是...
c语言:通用链表
yeye924的博客
09-22 336
在以后的代码生涯中肯定不会缺少链表的使用，为了使用方便，可以制作一个通用链表。 typedef int (*CMP)(const void*,const void*); typedef void (*SHOW)(const void*); typedef struct Node { void* data; struct Node* prev; struct Node* next; }Node; Node* create_node(void* data) { Node* node = malloc
【C语言基础（十）】通用链表
paidaxing_s的博客
01-21 613
透彻理解为什么要设计通用链表、对通用链表的几种基本操作详细讲解
C语言实现的通用链表
oria2006的专栏
11-25 397
大部分C实现的链表（包括教材上的实例）都是将链表结构和链表节点的值写在同一个结构体中，如下 typedef struct mlist_node { int value; struct mlist_node *next; struct mlist_node *prev; }mlist_node_t; 很显然这样代码无法通用性，换一个功能value可能就是char或者结构类型了。 为了实现通用性，节点可以这样定义，将节点的value定义成指针类型，他可以指向任意值 typed
纯c语言通用链表
一个人的旅行的博客
05-08 1636
纯c语言通用链表 概述 c语言标准库不存在链表, 所以为了数据的简单操作自己写了一份链表 代码 ############               general_list.h             ############## #ifndef __GENERAL_LIST_H__ #define __GENERAL_LIST_H__
C语言教程：链表中插入新节点的详细步骤
链表是一种数据结构，其中每个元素（称为节点）包含数据和一个指向下一个节点的指针。在C语言中，操作链表通常涉及动态内存分配和指针操作。在本教程中，重点讲解了如何向链表中插入新节点的过程： 1. **初始化链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值