数据结构 双向链表的数据封装

已于 2024-08-06 11:52:44 修改
阅读量162 收藏
点赞数 3
文章标签： 数据结构 链表 linux
于 2024-08-06 11:42:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ksk6666/article/details/140951650
版权

链表

定义数据结构：

typedef void (llist_op_t)(const void *);
typedef int (llist_cmp_t)(const void * , const void *);
typedef void (llist_mod_t)(void *, const void *);

//抽象数据类型
typedef struct node_t{
	void *data;
	struct node_t *next;
	struct node_t *prev;
}NODE;

typedef struct llist_t{
	NODE head;
	int size;
	int count;	
}LLIST;

//==============insert======================
void llist_append(LLIST *handle, void *data);
void llist_appprev(LLIST *handle, void *data);
void llist_index_insert(LLIST *handle, void *data, int index);

//================del=================
void llist_first_del(LLIST *handle, void *key, llist_cmp_t *cmp);
void llist_end_del(LLIST *handle, void *key, llist_cmp_t *cmp);
void llist_all_del(LLIST *handle, void *key, llist_cmp_t *cmp);
void llist_index_del(LLIST *handle, int index);

//=============find=======================
void *llist_first_find(LLIST *handle, void *key, llist_cmp_t *cmp);
void *llist_end_find(LLIST *handle, void *key, llist_cmp_t *cmp);
LLIST *llist_all_find(LLIST *handle, void *key, llist_cmp_t *cmp);
void *llist_index_find(LLIST *handle, int index);

//===============mod=====================
void llist_first_mod(LLIST *handle, void *old_key, llist_cmp_t *cmp, void *new_key, llist_mod_t *mod);
void llist_end_mod(LLIST *handle, void *old_key, llist_cmp_t *cmp, void *new_key, llist_mod_t *mod);
void llist_all_mod(LLIST *handle, void *old_key, llist_cmp_t *cmp, void *new_key, llist_mod_t *mod);
void llist_index_mod(LLIST *handle, int index, void *new_key, llist_mod_t *mod);

//============sort=================
void llist_sort(LLIST *handle, llist_cmp_t *cmp);

//================fileio===============
void llist_store(LLIST *handle, const char *path);
LLIST *llist_load(const char *path);

//=================llist_copy==========
LLIST *llist_copy(LLIST *handle);

//==========llist_inti==============
LLIST *llist_creat(int size);
//===========llist_travel===========
void llist_travel(LLIST *handle, llist_op_t *op);
//==========llist_destroy============
void llist_destroy(LLIST **handle);
//==========llist_count=============
int llist_num(LLIST *handle);

//insert

void llist_append(LLIST *handle, void *data)
{
    ERRP(NULL == data, data NULL, goto ERR1);

    NODE *new = NULL;

    new = (NODE *)malloc(sizeof(NODE));
    ERRP(NULL == new, malloc new, goto ERR1);

    new->data = (void *)malloc(handle->size);
    ERRP(NULL == new->data, new->data NULL, goto ERR2);

    memmove(new->data, data, handle->size);

    new->next = &handle->head;
    new->prev = handle->head.prev;
    handle->head.prev->next = new;
    handle->head.prev = new;

    handle->count++;

    return;
ERR2:
    free(new);
ERR1:
    return;
}

void llist_appprev(LLIST *handle, void *data)
{
    ERRP(NULL == data, data NULL, goto ERR1);

    NODE *new = NULL;

    new = (NODE *)malloc(sizeof(NODE));
    ERRP(NULL == new, malloc new, goto ERR1);

    new->data = (void *)malloc(handle->size);
    ERRP(NULL == new->data, new->data NULL, goto ERR2);

    memmove(new->data, data, handle->size);

    new->next = handle->head.next;
    new->prev = &handle->head;
    handle->head.next->prev = new;
    handle->head.next = new;

    handle->count++;
    return;
ERR2:
    free(new);
ERR1:
    return;
}

void llist_index_insert(LLIST *handle, void *data, int index)
{
    ERRP(index > handle->count || index < 0, index error, goto ERR1);
    ERRP(NULL == data, data NULL, goto ERR1);

    NODE *new = NULL;

    new = (NODE *)malloc(sizeof(NODE));
    ERRP(NULL == new, malloc new, goto ERR1);

    new->data = (void *)malloc(handle->size);
    ERRP(NULL == new->data, new->data NULL, goto ERR2);

    memmove(new->data, data, handle->size);

    NODE *tail = &handle->head;
    int count = 0;
    while (count != index)
    {
        tail = tail->next;
        count++;
    }
    new->next = tail->next;
    new->prev = tail;
    tail->next->prev = new;
    tail->next = new;

    handle->count++;
    return;
ERR2:
    free(new);
ERR1:
    return;
}

//del

void llist_first_del(LLIST *handle, void *key, llist_cmp_t *cmp)
{
    NODE *tail = NULL;
    for (tail = handle->head.next; tail != &handle->head; tail = tail->next)
    {
        if (cmp(tail->data, key) == 0)
        {
            tail->prev->next = tail->next;
            tail->next->prev = tail->prev;
            free(tail->data);
            free(tail);
            handle->count--;
            return;
        }
    }
    return;
}

void llist_end_del(LLIST *handle, void *key, llist_cmp_t *cmp)
{
    NODE *tail = NULL;
    for (tail = handle->head.prev; tail != &handle->head; tail = tail->prev)
    {
        if (cmp(tail->data, key) == 0)
        {
            tail->prev->next = tail->next;
            tail->next->prev = tail->prev;
            free(tail->data);
            free(tail);
            handle->count--;
            return;
        }
    }
    return;
}

void llist_all_del(LLIST *handle, void *key, llist_cmp_t *cmp)
{
    NODE *tail = NULL, *new = NULL;
    for (tail = handle->head.next; tail != &handle->head; tail = new)
    {
        if (cmp(tail->data, key) == 0)
        {
            new = tail->next;
            tail->prev->next = tail->next;
            tail->next->prev = tail->prev;
            free(tail->data);
            free(tail);
            handle->count--;
            tail = tail->prev;
        }
        else
        {
            new = tail->next;
        }
    }
    return;
}

void llist_index_del(LLIST *handle, int index)
{
    ERRP(index >= handle->count || index < 0, index error, goto ERR1);

    int count = 0;
    NODE *tail = handle->head.next;
    while (count != index)
    {
        tail = tail->next;
        count++;
    }
    tail->prev->next = tail->next;
    tail->next->prev = tail->prev;
    free(tail->data);
    free(tail);
    handle->count--;
    return;

ERR1:
    return;
}

//find

void *llist_first_find(LLIST *handle, void *key, llist_cmp_t *cmp)
{
    NODE *tail = NULL;

    for (tail = handle->head.next; tail != &handle->head; tail = tail->next)
    {
        if (cmp(tail->data, key) == 0)
        {
            return tail->data;
        }
    }

    return NULL;
}

void *llist_end_find(LLIST *handle, void *key, llist_cmp_t *cmp)
{
    NODE *tail = NULL;

    for (tail = handle->head.prev; tail != &handle->head; tail = tail->prev)
    {
        if (cmp(tail->data, key) == 0)
        {
            return tail->data;
        }
    }

    return NULL;
}

LLIST *llist_all_find(LLIST *handle, void *key, llist_cmp_t *cmp)
{
    LLIST *temp = NULL;
    temp = llist_creat(handle->size);
    ERRP(NULL == temp, malloc temp, goto ERR1);

    NODE *tail = NULL;
    for (tail = handle->head.next; tail != &handle->head; tail = tail->next)
    {
        if (cmp(tail->data, key) == 0)
        {
            llist_append(temp, tail->data);
        }
    }
    return temp;
ERR1:
    return NULL;
}

void *llist_index_find(LLIST *handle, int index)
{
    NODE *tail = NULL;
    int count = 0;
    for (tail = handle->head.next; tail != &handle->head; tail = tail->next)
    {
        if (index == count)
        {
            return tail->data;
        }
        else
        {
            count++;
        }
    }

    return NULL;
}

//mod

void llist_first_mod(LLIST *handle, void *old_key, llist_cmp_t *cmp, void *new_key, llist_mod_t *mod)
{
    NODE *tail = NULL;

    for (tail = handle->head.next; tail != &handle->head; tail = tail->next)
    {
        if (cmp(tail->data, old_key) == 0)
        {
            mod(tail->data, new_key);
            return;
        }
    }

    return;
}

void llist_end_mod(LLIST *handle, void *old_key, llist_cmp_t *cmp, void *new_key, llist_mod_t *mod)
{
    NODE *tail = NULL;

    for (tail = handle->head.prev; tail != &handle->head; tail = tail->prev)
    {
        if (cmp(tail->data, old_key) == 0)
        {
            mod(tail->data, new_key);
            return;
        }
    }

    return;
}

void llist_all_mod(LLIST *handle, void *old_key, llist_cmp_t *cmp, void *new_key, llist_mod_t *mod)
{
    NODE *tail = NULL;

    for (tail = handle->head.next; tail != &handle->head; tail = tail->next)
    {
        if (cmp(tail->data, old_key) == 0)
        {
            mod(tail->data, new_key);
        }
    }

    return;
}

void llist_index_mod(LLIST *handle, int index, void *new_key, llist_mod_t *mod)
{
    ERRP(index > handle->count || index < 0, index error, goto ERR1);
    void *tail = llist_index_find(handle, index);
    mod(tail, new_key);

ERR1:
    return;
}

//sort

void llist_sort(LLIST *handle, llist_cmp_t *cmp)
{
    NODE *i = NULL;
    NODE *j = NULL;
    void *new = NULL;

    new = (void *)malloc(handle->size);
    ERRP(NULL == new, new NULL, goto ERR1);

    for (i = handle->head.next; i != &handle->head; i = i->next)
    {
        for (j = handle->head.next; j->next != &handle->head; j = j->next)
        {
            if (cmp(j->data, j->next->data))
            {
                memmove(new, j->data, handle->size);
                memmove(j->data, j->next->data, handle->size);
                memmove(j->next->data, new, handle->size);
            }
        }
    }
    free(new);

    return;
ERR1:
    return;
}

//fileio

void llist_store(LLIST *handle, const char *path)
{
    FILE *fp = NULL;
    NODE *tail = NULL;

    fp = fopen(path, "w");
    ERRP(NULL == fp, fp open, goto ERR1);

    if (fwrite(handle, sizeof(*handle), 1, fp) != 1)
    {
        perror("fwrite");
        goto ERR2;
    }

    for (tail = handle->head.next; tail != &handle->head; tail = tail->next)
    {
        if(fwrite(tail->data , handle->size , 1 ,fp) != 1)
        {
            perror("fwrite");
            goto ERR2;
        }
    }

    fclose(fp);
    return ;
ERR2:
    fclose(fp);
ERR1:
    return;
}

LLIST *llist_load(const char *path)
{
    FILE *fp = NULL;
    LLIST *handle = NULL;
    void *tail = NULL;
    int i;
    
    handle = (LLIST*)malloc(sizeof(LLIST));
    ERRP(NULL == handle , malloc handle , goto ERR1);

    fp = fopen(path, "r");
    ERRP(NULL == fp, fp open, goto ERR2);

    if(fread(handle , sizeof(*handle) , 1 , fp) != 1)
    {
        perror("fread");
		goto ERR3;
    }

    handle->head.data = NULL;
    handle->head.next = &handle->head;
    handle->head.prev = &handle->head;
    
    for(i=0 ;i < handle->count ;i++)
    {
        tail = (void*)malloc(handle->size);
        ERRP(NULL == tail , tail malloc , goto ERR3);

        if(fread(tail , handle->size , 1 ,fp)!=1)
        {
            perror("fread");
		    goto ERR3;
        }
        
        llist_append(handle,tail);
        handle->count--;
    }

    fclose(fp);
    return handle;

ERR3:	
	fclose(fp);
    llist_destroy(&handle);
ERR2:
	free(handle);
ERR1:
	return NULL;
}

//copy

LLIST *llist_copy(LLIST *handle)
{
    LLIST * newhandle = NULL;
    NODE *tail = handle->head.next;

    newhandle = llist_creat(handle->size);
    ERRP(NULL == newhandle , newhandle init , goto ERR1);

    while(tail != &handle->head)
    {
        llist_append(newhandle,tail->data);
        tail = tail->next;
    }

    return newhandle;
ERR1: 
    return NULL;
}

//count nmu

int llist_num(LLIST *handle)
{
    return handle->count;
}

//init

LLIST *llist_creat(int size)
{
    LLIST *handle = NULL;

    handle = (LLIST *)malloc(sizeof(LLIST));
    ERRP(NULL == handle, malloc handle, goto ERR1);

    handle->head.data = NULL;
    handle->head.next = &handle->head;
    handle->head.prev = &handle->head;
    handle->size = size;
    handle->count = 0;

    return handle;
ERR1:
    return NULL;
}

//traval

void llist_travel(LLIST *handle, llist_op_t *op)
{
    NODE *tail = NULL;

    for (tail = handle->head.next; tail != &handle->head; tail = tail->next)
    {
        op(tail->data);
    }
}

//destroy

void llist_destroy(LLIST **handle)
{
    NODE *tail = NULL;
    NODE *sava = NULL;

    for (tail = (*handle)->head.next; tail != &(*handle)->head; tail = sava)
    {
        sava = tail->next;
        free(tail->data);
        free(tail);
    }
    free(*handle);
    *handle = NULL;
}

只是想学习
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构-双向链表
qq_43714814的博客
12-12 1955
数据结构-双向链表
数据结构 双向链表（C++）
06-07
双向链表是一种特殊的数据结构，它在计算机程序设计中扮演着重要角色，特别是在C++这样的编程语言中。本节将深入探讨双向链表的概念、其结构、操作以及C++中的实现。 双向链表与单链表不同，它允许每个节点不仅有一...
数据结构——双向链表
麦麦的博客
03-11 2209
数据结构——双向链表：本文对双向链表的功能实现进行了详细地讲解，并与单链表的实现进行对比，干货满满，图文并茂，过万好文，不容错过！！！
数据结构—双向链表（详解）
梅山
03-20 6181
双向链表 在之前一篇文章中介绍了单向链表的实现，可以看出单向链表实现过程中，只能够逐次向下继续查找，指针一直指向下一个节点，而本文中的双向链表，在结构体定义的时候多了一个指向上一节点的指针，因此，无论是在插入还是删除来说，从后往前和从前往后遍历都极大的提高了便利性。下面来介绍双向链表的具体实现。 双向非循环链表的实现 1、链表结构体封装 /* 双向链表的结构 */ typedef struct llist_st { int data; struct llist_st * prev;
数据结构—双向链表
2301_79601095的博客
07-19 1437
先介绍双向链表与单链表的区别，再详细描述各种接口功能的实现和代码实现，最后对比顺序表和链表的区别，再贴上实现双向链表的源代码
【数据结构】单链表 双向链表
yj20040627的博客
07-11 3198
单链表 双向链表实现
【数据结构与算法】之双向链表及其实现！
2301_80221228的博客
04-16 1969
​。
数据结构——双向循环链表
qq_67611811的博客
08-28 2104
双向循环链表，在原单链表的基础上多了一个指向上一个结点的前驱指针prev，这样前后结点就不仅仅有了单向的从头至尾的指向顺序，也可以从后指向前，从末结点指向头结点。双向带头循环链表结构} DGR;加入前驱指针后，不管是对于链表数据的尾插尾删，或是头插头删，其时间复杂度都为O(1)，大大简化了链表遍历过程，而可以直接在链表首尾增减数据，因为一个链表的末节点可由头结点的前驱指针直接访问而不需要遍历至尾。为了简化文本描述，本章双向循环带头链表均简称为双向链表。...
数据结构51-封装双向链表
qq_41632427的博客
12-13 102
前端
【数据结构】动图详解双向链表
忆梦初心的博客
02-04 1709
带头双向循环链表：其结构是链表8种结构中最复杂的，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。此链表的结点在单向链表的基础上，添加了前驱指针prev指向上一个结点，然后添加了上述所描述的头结点，而循环则是体现在首尾结点相连上。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现起来反而更加简单。通过上面一个个接口的实现，我们发现：虽然双向带头循环链表的结构比起单向链表结构复杂太多，但对于各接口的实现反而变得更加方便，并且某些接口时间效率更高
数据结构：手撕图解双向循环链表
海绵宝宝de派小星的博客
07-10 4231
双向循环链表的手撕实现和图解 分析对比其与单链表的差异
数据结构单双链表c++版
07-14
这样的设计使得双向链表可以更灵活地进行前向和后向遍历，同时也使得插入和删除操作更为便捷，因为可以从两个方向找到相邻节点。然而，相比于单链表，双链表需要更多的内存来存储额外的指针。 在Dev-C++这样的集成...
【数据结构与算法 - 链表】
04-18
链表是一种基础且重要的数据结构，它在计算机科学和编程中扮演着不可或缺的角色。相比于数组，链表在存储和操作动态数据集时提供了更大的灵活性。本资料包专注于讲解链表及其在C语言中的实现，强调模块化设计，使得...
基于C++数据结构双向循环链表实现的贪吃蛇【100010175】
12-26
结构：把相应的功能模块化，结构化，封装成一个个函数，像蛇逻辑有自噬死亡，撞墙死亡，吃食，变长等 交互：在相应的自定义逻辑函数中调用各自的函数，主函数则主要写下简短的循环框架，直到游戏结束
带头结点的双向循环链表
07-17
总结来说，带头结点的双向循环链表是一种灵活且实用的数据结构，它在C++中的实现涉及节点定义、链表操作的实现以及封装为类。理解并掌握这一数据结构对于提升编程能力，尤其是处理复杂算法问题具有重要意义。
排序（归并排序，非比较排序）
qq_63074244的博客
08-20 524
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的 相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，⽽在排序后的序列中，r[i]仍在r[j]之 前，则称这种排序算法是稳定的；否则称为不稳定的。数据结构结构初阶的排序基本上总结完毕了，这里我学了冒泡，插入，选择，快排，希尔，堆，归并，计数排序，这几种排序在时间复杂度，空间复杂度以及稳定性上各有各的优点。下面我们用一张图进行总结。
数据结构之树的存储结构
DKPT的博客
08-16 532
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
【Java & 数据结构】初识二叉树
最新发布
qq_42150700的博客
08-20 455
树是一种非线性的数据结构, 也就是说它和我们前面学习的顺序表链表之类的不太一样. 那些数据结构要求中间的元素都只有一个前驱和后继, 而树型结构的中间元素则允许有多个后继.例如下面这个就是一个树形结构为什么叫这种结构为树形结构呢?这是因为它的结构长的就像一颗倒过来的树, 最上面是树根, 最下面则是叶子.下面我们看几个例子, 来认识一下树形结构的注意点下面的这个结构, 就不是一个树形结构, 原因是其中间在同一层的节点, 是不可以相连的, 中间的节点只允许和上层节点和下层节点进行连接.
数据结构【顺序结构二叉树：堆】（1）
qq_67578580的博客
08-20 524
堆排序时间复杂度计算。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值