4.数据结构之通用链表实现

最新推荐文章于 2022-05-13 18:06:21 发布
最新推荐文章于 2022-05-13 18:06:21 发布
阅读量870 收藏
点赞数 1
分类专栏： 数据结构 C语言 文章标签： redis 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linux_player_c/article/details/49302975
版权

数据结构之通用链表实现

通用链表简介

在redis数据库和acl库中，通用双端链表的应用随处可见。之前我们接触过链表的相关操作，前两章：《数据结构之单链表》以及《数据结构之链表面试题》接触了不少链表的问题，但是对于问题的处理总是无法逃脱类型的限定，所以我们需要将类型的问题从数据结构中剥离出来。具体的类型在数据结构的使用者进行具体的限定。好吧，我们首先来看看头文件dlist.h中关于链表节点结构的定义和接口的声明：

//防止头文件的内容被重复包含
#ifndef _DLIST_H_
#define _DLIST_H_

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

#define ZERO       (0)
#define ONLY_ONE   (1)
#define TRUE       (1)
#define FALSE      (0)

struct Dlist;
typedef struct Dlist Dlist;             //双端链表控制信息

struct Dlist_node;
typedef struct Dlist_node Dlist_node;   //双短链表节点信息

typedef unsigned char Boolean;          //C语言中的布尔值

//链表控制信息
struct Dlist{   
    struct Dlist_node *head;   //指向双端链表的头节点
    struct Dlist_node *tail;   //指向双端链表的尾节点
    int               count;   //双端链表中的元素个数

    //释放链表节点数据域
    void    (*free)(void *ptr);    //void (*)(void *ptr)  free;
    //匹配链表节点数据域
    Boolean (*match)(void *val1, void *val2);
    //拷贝链表节点数据域
    void    *(*copy_node)(void *src);
};

//链表节点信息
struct Dlist_node{
    struct Dlist_node *prev;    //前一个节点指针
    struct Dlist_node *next;    //后一个节点指针
    void              *data;    //数据（指针）
};

typedef void (*Print_func)(void *value);

//双端链表的接口(ADT)
Dlist      *init_dlist(void)                    ;    //链表的初始化
void       destroy_dlist(Dlist **dlist)         ;    //链表的销毁
Boolean    push_front(Dlist *dlist, void *value);    //链表头部插入
Boolean    push_back(Dlist *dlist, void *value) ;    //链表尾部插入
Boolean    pop_back(Dlist *dlist)               ;    //链表尾部删除
Boolean    pop_front(Dlist *dlist)              ;    //链表头部删除
Boolean    insert_prev_node(Dlist *dlist,
             Dlist_node *node, void *value)     ;    //插入指定节点的前边
Boolean    insert_next_node(Dlist *dlist,
             Dlist_node *node, void *value)     ;    //插入指定节点的后边
Boolean    remove_dlist_node(Dlist *dlist,
             Dlist_node *node, void **value)             ;    //删除链表中的节点    
void       print_dlist(Dlist *dlist, Print_func print)   ;    //打印双端链表
Dlist_node  *get_index_node(Dlist *dlist, int index)     ;    //得到下标为index的链表元素
Boolean    get_front(Dlist *dlist, void **value)         ;    //得到链表头节点的数据域
Boolean    get_tail(Dlist *dlist, void **value)          ;    //得到链表尾节点的数据域
int        get_dlist_count(Dlist *dlist)                 ;    //得到链表元素个数


//
void print_int(void *value);    //打印整形值

#endif

在参数传递中我们对于数据的传递都是采用的指针的传递，并且都是void *类型，这样就可以接受任意类型的数据。在结构上我们依然设计了链表控制信息和链表节点信息两部分，这里我们使用了函数指针的技术，函数指针可以让该指针指向相同类型的函数（返回值和参数列表相同）。首先我们得定义出函数指针的这种类型：

typedef void (*Print_func)(void *value);

这就是说Print_func是一种类型，这种类型可以定义相关指针，该指针可以指向型如
void func1(void *value)类型的函数。

关于链表接口的实现我们在dlist.c中进行实现，代码如下所示：

#include "dlist.h"
#include "tools.h"


void       destroy_dlist(Dlist **dlist)    //链表的销毁
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || *dlist == NULL){
        return ;
    }

    p_node = (*dlist)->head;

    while((*dlist)->head != NULL){
        (*dlist)->head = p_node->next;
        if((*dlist)->free != NULL){
            (*dlist)->free(p_node->data);
        }
        free(p_node);
        p_node = (*dlist)->head;
    }
    free(*dlist);
    *dlist = NULL;

}

static Dlist_node *buy_node(void)
{
    Dlist_node *result = (Dlist_node *)Malloc(sizeof(Dlist_node));
    bzero(result, sizeof(Dlist_node));

    return result;
}

Boolean    push_front(Dlist *dlist, void *value)    //链表头部插入
{
    Dlist_node *node = NULL;

    if(dlist == NULL || value == NULL){
        return FALSE;
    }

    node = buy_node();
    node->data = value;

    if(dlist->count == ZERO){    //链表没有元素时
        dlist->head = dlist->tail = node;
    }else{
        node->next = dlist->head;
        dlist->head->prev = node;
        dlist->head = node;
    }
    dlist->count++;
    return TRUE;
}

Boolean    push_back(Dlist *dlist, void *value)    //链表尾部插入
{
    Dlist_node *node = NULL;

    if(dlist == NULL || value == NULL){
        return FALSE;
    }

    node = buy_node();
    node->data =value;

    if(dlist->count == ZERO){
        dlist->head = dlist->tail = node;
    }else{
        node->prev = dlist->tail;
        dlist->tail->next = node;
        dlist->tail = node;
    }
    dlist->count++;
    return TRUE;
}
Boolean    pop_back(Dlist *dlist)    //链表尾部删除
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || dlist->count == ZERO){
        return FALSE;
    }

    p_node = dlist->tail;

    if(dlist->count == ONLY_ONE){
        dlist->head = dlist->tail = NULL;
    }else{
        dlist->tail = p_node->prev;
        dlist->tail->next = NULL;
    } 
    if(dlist->free != NULL){
        dlist->free(p_node->data);
    }
    free(p_node);
    dlist->count--;
    return TRUE;
}
Boolean    pop_front(Dlist *dlist)    //链表头部删除
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || dlist->count == ZERO){
        return FALSE;
    }

    p_node = dlist->head;

    if(dlist->count == ONLY_ONE){
        dlist->head = dlist->tail = NULL;
    }else{
        dlist->head = p_node->next;
        dlist->head->prev = NULL;
    }
    if(dlist->free != NULL){
        dlist->free(p_node->data);
    }
    free(p_node);
    dlist->count--;
    return TRUE;
}

Dlist_node *get_index_node(Dlist *dlist, int index)   //得到下标为index的链表节点
{
    Dlist_node *node = NULL;
    int move_count = 0;

    if(dlist == NULL || dlist->count == ZERO
    || index < ZERO || index >= dlist->count){
         return NULL;
    }

    node = dlist->head;
    move_count = index;

    //找到指定下标元素
    while(move_count--){
        node = node->next;
    }

    return node;
}

Boolean    remove_dlist_node(Dlist *dlist, 
               Dlist_node *node, void **value)    //删除指定节点
{
    if(dlist == NULL || node == NULL){
        return FALSE;
    }

    if(value != NULL){    //取得被删除节点数据域信息
        *value = node->data;
    }

    if(node->next == NULL){    //node在尾部
        pop_back(dlist);
    }else if(node->prev == NULL){
        pop_front(dlist);
    }else{
        node->prev->next = node->next;
        node->next->prev = node->prev;
        if(dlist->free != NULL){
            dlist->free(node->data); 
        }
        free(node);   //Free(node)
        dlist->count--;

        /*
 *
 * #define Free(node) (node->prev->next = node->next;) \
 *                    (node->next->prev = node->prev;) \
 *                    
 *
 * */
    }
    return TRUE;
}

Boolean    insert_next_node(Dlist *dlist,
               Dlist_node *node, void *value)    //插入到指定节点的后边
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || node == NULL || value){
        return FALSE;
    }

    p_node = buy_node();
    p_node->data = value;

    p_node->prev = node;
    p_node->next = node->next;
    if(node->next == NULL){
        dlist->tail = p_node;
    }else{
        node->next->prev = p_node;
    }
    node->next = p_node;
    dlist->count++;
    return TRUE;
}

Boolean    insert_prev_node(Dlist *dlist,
               Dlist_node *node, void *value)    //插入到指定节点的前边
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || node == NULL || value == NULL){
        return FALSE;
    }

    p_node = buy_node();
    p_node->data = value;

    //进行插入操作
    p_node->next = node;
    p_node->prev = node->prev;
    if(node->prev == NULL){    //node为第一个节点
        dlist->head = p_node;
    }else{    //node不是第一个节点
        node->prev->next = p_node;
    }
    node->prev = p_node;
    dlist->count++; 
    return TRUE;
}

void print_int(void *value)
{
    printf("%d ", *(int *)value);
}

void print_dlist(Dlist *dlist, Print_func print)    //打印链表信息
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || dlist->count == ZERO){
        return ;
    }

    for(p_node = dlist->head; p_node ; p_node = p_node->next){
        print(p_node->data);
    }
    printf("\n");
}


Dlist *init_dlist(void)    //双端链表的初始化
{
    Dlist *dlist = NULL; 

    dlist = (Dlist *)Malloc(sizeof(Dlist));
    bzero(dlist, sizeof(Dlist));   //对dlist进行初始化

    return dlist;
}

Boolean get_front(Dlist *dlist, void **value)
{
    if(dlist == NULL || dlist->count == ZERO){
        return FALSE;
    }

    if(value != NULL){
        *value = dlist->head->data;
    }
    return TRUE;
}

Boolean get_tail(Dlist *dlist, void **value)
{
    if(dlist == NULL || dlist->count == ZERO){ 
        return FALSE;
    }

    if(value != NULL){
         *value = dlist->tail->data;
    }
    return TRUE;
}

int get_dlist_count(Dlist *dlist)
{
    if(dlist == NULL){
        return -1;
    }
    return dlist->count;
}

在dlist.c文件中我们包含了一个tools.h,这个是我们的工具类文件，其中包含了对内存和简单算法的相关接口，分为tools.h和tools.c两个文件：

#ifndef _TOOLS_H_
#define _TOOLS_H_

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

void *Malloc(size_t size);   //申请堆空间
void swap(void *a, void *b, int length);   //交换任意两个值
#endif

对应的tools.c文件：

#include "tools.h"

void *Malloc(size_t size)
{
    void *result = malloc(size);
    if(result == NULL){ 
        fprintf(stderr, "the memory is full!\n");
        exit(1);
    } 
    return result;
}

void swap(void *a, void *b, int length)
{
    void *temp = malloc(length);
    memcpy(temp, a, length);
    memcpy(a, b, length);
    memcpy(b, temp, length);

    free(temp);
}

关于通用链表的测试代码入下所示：

//通用链表测试代码
#include <stdio.h>
#include "dlist.h"

int main(int argc, char **argv)
{
    Dlist *dlist1 = NULL;
    int array[] = {12, 23, 34, 4, 1, 33, 24};
    int array1[] = {1, 33, 44, 2, 33, 222, 444};
    int arr_len = sizeof(array) / sizeof(array[0]);
    int i  = 0;   

    dlist1 = init_dlist();   //双端链表的初始化
    //初始化完成后，如果有需要，应修改free、match和dup的指向

    for(i = 0; i < arr_len; ++i){
        push_back(dlist1, &array[i]);       
    }

    print_dlist(dlist1, print_int);
    pop_back(dlist1);

    push_front(dlist1, &array1[2]);


    print_dlist(dlist1, print_int);

    destroy_dlist(&dlist1);    //双端链表的销毁
    return 0;
}

通用链表在redis数据库中具有着非常多的应用：
可以作为底层容器的实现，用来改造，添加保存节点长度的字段。或者说python的基本数据类型列表、元组的底层容器。以及后期我们将要使用适配器模式对通用双端链表进行封装，创建出栈和队列。

敬请期待！

linux_player_c
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Pintos基础数据结构：通用链表
Junds0的博客
03-05 1103
由于具体应用中仍然需要对存储于‘链表结点’中的数据进行访问，因此，就需要从指向‘链表元素’的指针推算出包含它的那个‘链表结点’的指针。为此，PINTOS 中引入了一个宏 list_entry，其定义和基本思想如图所示：如果已知某个‘链表元素’的指针为 p，并且该‘链表元素’以字段 elem 的形式包含在‘链表结点’结构 list_nodei 中，宏调用list_entry(p,structlist_nodei,elem)经过展开后就是指向包含该‘链表元素’的‘链表结点’的指针。那么这个指针变量怎么定义呢？
2.3.1 使用指针实现的链表
RetenQ的博客
11-18 960
链表(指针) 在存储一大波数的时候，如果使用数组，有时会感到数组显得不太灵活 我们可以在C语言中使用指针和动态分配函数malloc来实现链表 关于指针，这里就不赘述了，默认已经了解相关知识 指针实现 malloc malloc 函数的作用就是从内存中申请分配指定字节大小的内存空间 malloc(4); //这样就申请了四个字节大小的内存空间 如果不知道字节大小，那么使用sizeof()查看就好了 malloc 函数的返回值是void*，也就是未确定类型的指针，它可以被强制转换为任何其它类型的指针
基础数据结构：链表
m0_62126248的博客
05-13 421
模拟实现基础数据结构-单链表
通用链表操作接口函数
young honker
06-20 1804
list.c/* * *通用链表操作函数定义 ** */ #include #include #include #include "list.h" /*链表初始化*/ void list_init(List *list) { list->head = NULL; list->tail = NULL; list->len = 0; } /*是否为空链表*/ boo
基于链表指针结构体的使用方法
YangSong666的博客
07-27 2117
1. 什么是链表? ——链表是一种常见的重要的数据结构。是动态地进行存储分配的一种结构。链表有一个“头指针（head）”变量，该变量存放一个地址，该地址指向一个元素。链表中的每一个元素称为“结点”，这个结点包括：用户需要的实际数据和下一个结点的地址。 2.链表的使用 下面是学完了链表后，对链表的理解与代码的编写，以及构思思路，首先是链表的结点，是一个结构体，分为两部分组成: struct Link...
通用单链表（一）
03-11 443
通用单链表我们在学习链表的时候，大部分老师和大部分书籍都只会教我们常规的链表，此处常规是指链表的数据部分只适用单一的数据类型，对于怎么扩展到适用所有的数据类型，大多都是让学生自己去摸索，甚至根本就没有提及，可能中国的老师和作者都觉得每个学习数据结构的人都跟linux的创始人一样聪明吧！ 我在学习和写代码的过程中，觉得链表两个比较重要点大多数老师和书籍都语焉不详。 1. 链表节点的结构 2. 如
c语言数据结构之通用链表
xingweiyong的专栏
11-12 978
这篇文章对链表这种数据结构进行深入分析和改造，常规的链表数据域的数据类型都是固定的，借助void*通用指针可以实现通用型的链表，链表的数据域是可以存放任何数据类型，而不必每次都将数据类型固定下来，但是要求链表的数据要一致，不能同时存储多种数据类型。这篇文章是学习了一篇微信公众号文章，对其中的代码进行复现，文末会贴出该公众号的链接，并表示对作者的感谢和敬佩！ 首先构造链表节点数据类型，每一个节点包含
C通用范例源代码之数据结构之链表.pdf
06-23
在C语言中，链表是一种基础且重要的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。上述文件中包含了几个关于链表操作的C语言源代码范例，主要涉及链表的创建、遍历以及按序号查找节点。 ...
java链表是一种数据结构.docx
最新发布
03-13
**链表**是一种常见的线性数据结构，它与数组不同之处在于，链表中的元素不是连续存储的，而是通过节点之间的指针（或引用）链接在一起。每个节点通常包含两部分：数据域和指针域。 #### 二、Java中的链表实现 在...
通用的C++数据结构代码实现.zip
07-27
这个名为“通用的C++数据结构代码实现.zip”的压缩包很可能包含了一系列常见数据结构的C++实现，如数组、链表、栈、队列、树、图、哈希表等。下面将详细介绍这些数据结构及其在C++中的实现方法。 1. **数组**：数组...
JavaScript实现的链表数据结构实例
10-24
以下是一个JavaScript实现的链表数据结构实例，包括链表的基本操作以及排序功能。 首先，我们定义了一个`Node`构造函数，用于创建链表中的节点。每个节点有两个属性：`data`用于存储数据，`next`用于指向下一个节点...
数据结构——单向链表
huangjh2017的博客
01-09 752
1. 简介 　　链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比较于普通的线性表(数组)，链表有自己的优势和劣势： 单个结点创建非常方便，普通的线性内存通常在创
【C++】通用单链表
罗小黑の窝
07-05 1220
在C++的学习中，采用模板类，而采用虚函数实现多态性，达到通用的目的。结点类数据域被改造为指针，而把数据放在一个抽象类中，由指针与之建立联系。        采用虚函数实现多态性，达到通用的目的。堆内存的分配与释放，关键不是创建，而是释放！        要特别仔细揣摩堆内存的分配与释放，删除一个结点时系统自动调用结点类析构函数释放结点占用的动态内存，而结点释放时系统自动调用数据域类析构函
C 通用单向链表
韩搏专栏
10-13 3048
通用链表就是用一个共同的节点指针来操作不同的结构体数，不同的链表数据结构不同，但是可以共用链表操作函数，通用链表思维图如下：   通用链表操作代码和使用demo如下： main.c #include #include #include #include "linklist.h" typedef struct _Teacher { LinkListNode node; int
c语言实现通用数据结构（一）：通用链表
LiangJishengBlog
03-04 1216
&nbsp; &nbsp;忽然想起来，大概在两年之前学习C语言的时候，曾经用C语言写过一些通用的数据结构。主要也就实现了链表、队列、椎、HashSet，还有HashMap。当时只是知道标准的C语言中没有这方面的类库，后来才知道有很多第三方的类似这样的类库。废话不多说，先把代码粘过来。 下面实现的是通用链表，注意链表中只存储了指针，没有储存实际的数据。 头文件 [cpp] view p...
通用链表---通用链表的基本使用
cc_light_boy的博客
08-21 2877
通用链表 学习使用通用链表之前肯定写过的单向链表或者双向链表，以上两种链表在同一条链上只能挂在同一类型的结构体，因为不同结构体中的指针域类型不相同，所以通用链表很好的解决了这个问题，说到这里，相信在你的脑海已经有了通用链表的架构了，接下来我来详细的介绍一下通用链表的创建和基本应用。 1.双向链表和通用链表图解对比 1.1 双向链表指针域图解 从图中可以看出双向链...
通用数据结构设计--单向链表（1）
flowersjtq的博客
06-19 168
通用单向链表设计 我们的目标是设计一个完美的通用单向链表，什么叫完美？我也说不上来，但是我们可以去做，像写小说一样，我们想写出优秀的小说，必须需要看大量的其他优秀的小说，这是第一步，吸收它的优点，这是第二步，吸收后灵活使用在自己的小说里，这是第三步。 有些人对代码没有更高的追求，往往在看懂其他人的代码，并不会进行深入的第二步和第三步，这样看代码只会学到一些代码中亮眼的一些设计，也就是学到一些皮毛，而我们数据结构的设计会学习其他人的设计，提取出精华，分析出他的设计思维，再将大量的精华写入到我们的设计中，即是表
单向通用链表的封装
赵小厨的博客
08-04 195
单向通用链表 封装的链表结构 该图纯手画，头结点不存放数据，data指针为空，Next指向下一个结点。（也可以封装成头结点存放数据，代码稍作修改即可） 这里用一个用户结构体作为例子，进行测试。 typedef struct user { char acNo[20]; // 用户账号 char acName[20]; // 用户姓名 char acPsw[10]; // 登入密码 }U...
C语言实现数据结构链表操作示例
"这份资源是关于C语言实现数据结构中链表操作的通用范例源代码，包括了头插法建立单链表和限制链表长度建立长单链表的示例。" 在计算机科学中，链表是一种基础的数据结构，它由一系列节点（也称为元素或记录）组成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值