使用C语言实现“泛型”链表

最新推荐文章于 2024-05-28 23:08:31 发布
最新推荐文章于 2024-05-28 23:08:31 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： C/C++

看到这个标题，你可能非常惊讶，C语言也能实现泛型链表？我们知道链表是我们非常常用的数据结构，但是在C中却没有像C++中的STL那样有一个list的模板类，那么我们是否可以用C语言实现一个像STL中的list那样的泛型链表呢？答案是肯定的。下面就以本人的一个用C语言设计的链表为例子，来分析说明一下本人的设计和实现要点，希望能给你一点有用的帮助。

一、所用的链表类型的选择
我们知道，链表也有非常多的类型，包括单链表、单循环链表、双链表、双向循环链表等。在我的设计中，我的链表使用的类型是双向循环链表，并带一个不保存真实数据的头结点。其原因如下：
1）单链表由于不能从后继定位到前驱，在操作时较为不方便
2）双链表虽然能方便找到前驱，但是如果总是在其尾部插入或删除结点，为了定位的方便和操作的统一（所有的删除和插入操作，都跟在中间插入删除结点的操作一样），还要为其增加一个尾结点，并且程序还要保存一个指向这个尾结点的指针，并管理这个指针，从而增加程序的复杂性。而使用带头结点的循环双向链表，就能方便的定位（其上一个元素为链表的最后一个元素，其下一个元素为链表的第0个元素），并使所有的插入和删除的操作统一，因为头结点也是尾结点。注：结点的下标从0开始，头结点不算入下标值。
3）接口的使用与C++中stl中list和泛型算法的使用大致相同。

二、list类型的定义

为了让大家一睹为快，下面就给出这个用C语言实现的“泛型”的定义，再来说明，我这样设计的原因及要点，其定义如下：
其定义在文件list_v2.c中
[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <span style="font-size: 18px;">typedef struct node  
  2. {  
  3.     //循环双链表的结点结构  
  4.     void* data;//数据域指针  
  5.     struct node *next;//指向当前结点的下一结点  
  6.     struct node *last;//指向当前结点的上一结点  
  7. }Node;  
  8. struct list  
  9. {  
  10.     struct node *head;//头指针，指向头结点  
  11.     int data_size;//链表对应的数据所占内存的大小  
  12.     int length;//链表list的长度  
  13. };</span>  
typedef struct node
{
    //循环双链表的结点结构
    void* data;//数据域指针
    struct node *next;//指向当前结点的下一结点
    struct node *last;//指向当前结点的上一结点
}Node;
struct list
{
    struct node *head;//头指针，指向头结点
    int data_size;//链表对应的数据所占内存的大小
    int length;//链表list的长度
};
其声明在文件list_v2.h中
[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <span style="font-size: 18px;">//泛型循环双链表，带头结点，结点下标从0开始，头结点不计入下标值  
  2.   
  3. //定义结点指针Node*为List类型的迭代器  
  4. typedef struct node* Iterator;  
  5.   
  6. //List类型的定义  
  7. typedef struct list* List;  
  8.   
  9. //初始化链表,数据域所占内存的大小由data_size给出  
  10. int InitList(List *list, int data_size);  
  11.   
  12. //把data的内容插入到链表list的末尾  
  13. //assign指定数据data间的赋值方法  
  14. Iterator Append(List list, void *data,  
  15.                 void (*assign)(void*, const void*));  
  16.   
  17. //把data的内容插入到链表的迭代器it_before的前面  
  18. //assign指定数据data间的赋值方法  
  19. Iterator Insert(List list, void *data, Iterator it_before,  
  20.                 void (*assign)(void*, const void*));  
  21.   
  22. //把链表A中迭代器it_a指向的结点移动到链表B中迭代器it_b_befroe的前面  
  23. Iterator MoveFromAtoB(List A, Iterator it_a,  
  24.                       List B, Iterator it_b_before);  
  25.   
  26. //删除链表list中迭代器it指向的结点  
  27. int Remove(List list, Iterator it);  
  28.   
  29. //删除链表list的第0个结点，下标从0开始  
  30. int RemoveFirst(List list);  
  31.   
  32. //删除链表list的最后一个结点  
  33. int RemoveLast(List list);  
  34.   
  35. //返回list中第index个数据的指针  
  36. void* At(List list, int index);  
  37.   
  38. //在begin和end之间查找符合condition的第一个元素，  
  39. //比较函数由condition指向,比较的值由data指向  
  40. //当第一个参数的值小于第二个参数的值时，返回1，否则返回0  
  41. //根据condition函数的不同，可以查找第一个相等、大于或小于data的值  
  42. Iterator FindFirst(Iterator begin, Iterator end, void *data,  
  43.                        int (*condition)(const void*, const void*));  
  44.   
  45. //查找list中第一个与data相等的元素的下标，  
  46. //equal函数，当第一个参数与第二个参数的值相等时，返回1，否则返回0  
  47. int IndexOf(List list, void *data,  
  48.             int (*equal)(const void*,const void*));  
  49.   
  50. //查找在begin和end之间的最小值，比较函数由less指向  
  51. //当第一个参数的值小于第二个参数的值时，返回1，否则返回0  
  52. Iterator GetMin(Iterator begin, Iterator end,  
  53.                 int (*less)(const void*, const void*));  
  54.   
  55. //查找在begin和end之间的最大值，比较函数由large指向  
  56. //当第一个参数的值大于第二个参数的值时，返回1，否则返回0  
  57. Iterator GetMax(Iterator begin, Iterator end,  
  58.                 int (*large)(const void*, const void*));  
  59.   
  60. //获取list的长度  
  61. int GetLength(List list);  
  62.   
  63. //若list为空链表，则返回1，否则返回0  
  64. int IsEmpty(List list);  
  65.   
  66. //销毁list  
  67. void DestroyList(List *list);  
  68.   
  69. //获得list的首迭代器  
  70. Iterator Begin(List list);  
  71.   
  72. //获得list的尾迭代器，指向最后一个元素的下一个位置  
  73. Iterator End(List list);  
  74.   
  75. //使it指向下一个位置，并返回指向下一个位置后的迭代器  
  76. Iterator Next(Iterator *it);  
  77.   
  78. //使it指向上一个位置，并返回指向上一个位置后的迭代器  
  79. Iterator Last(Iterator *it);  
  80.   
  81. //通过迭代器it获得数据，相当于*p  
  82. void* GetData(Iterator it);  
  83.   
  84. //获取当前迭代器的下一个迭代器，注意，并不改变当前迭代器  
  85. Iterator GetNext(Iterator it);  
  86.   
  87. //获取当前迭代器的上一个迭代器，注意，并不改变当前迭代器  
  88. Iterator GetLast(Iterator it);</span>  
//泛型循环双链表，带头结点，结点下标从0开始，头结点不计入下标值

//定义结点指针Node*为List类型的迭代器
typedef struct node* Iterator;

//List类型的定义
typedef struct list* List;

//初始化链表,数据域所占内存的大小由data_size给出
int InitList(List *list, int data_size);

//把data的内容插入到链表list的末尾
//assign指定数据data间的赋值方法
Iterator Append(List list, void *data,
                void (*assign)(void*, const void*));

//把data的内容插入到链表的迭代器it_before的前面
//assign指定数据data间的赋值方法
Iterator Insert(List list, void *data, Iterator it_before,
                void (*assign)(void*, const void*));

//把链表A中迭代器it_a指向的结点移动到链表B中迭代器it_b_befroe的前面
Iterator MoveFromAtoB(List A, Iterator it_a,
                      List B, Iterator it_b_before);

//删除链表list中迭代器it指向的结点
int Remove(List list, Iterator it);

//删除链表list的第0个结点，下标从0开始
int RemoveFirst(List list);

//删除链表list的最后一个结点
int RemoveLast(List list);

//返回list中第index个数据的指针
void* At(List list, int index);

//在begin和end之间查找符合condition的第一个元素，
//比较函数由condition指向,比较的值由data指向
//当第一个参数的值小于第二个参数的值时，返回1，否则返回0
//根据condition函数的不同，可以查找第一个相等、大于或小于data的值
Iterator FindFirst(Iterator begin, Iterator end, void *data,
                       int (*condition)(const void*, const void*));

//查找list中第一个与data相等的元素的下标，
//equal函数，当第一个参数与第二个参数的值相等时，返回1，否则返回0
int IndexOf(List list, void *data,
            int (*equal)(const void*,const void*));

//查找在begin和end之间的最小值，比较函数由less指向
//当第一个参数的值小于第二个参数的值时，返回1，否则返回0
Iterator GetMin(Iterator begin, Iterator end,
                int (*less)(const void*, const void*));

//查找在begin和end之间的最大值，比较函数由large指向
//当第一个参数的值大于第二个参数的值时，返回1，否则返回0
Iterator GetMax(Iterator begin, Iterator end,
                int (*large)(const void*, const void*));

//获取list的长度
int GetLength(List list);

//若list为空链表，则返回1，否则返回0
int IsEmpty(List list);

//销毁list
void DestroyList(List *list);

//获得list的首迭代器
Iterator Begin(List list);

//获得list的尾迭代器，指向最后一个元素的下一个位置
Iterator End(List list);

//使it指向下一个位置，并返回指向下一个位置后的迭代器
Iterator Next(Iterator *it);

//使it指向上一个位置，并返回指向上一个位置后的迭代器
Iterator Last(Iterator *it);

//通过迭代器it获得数据，相当于*p
void* GetData(Iterator it);

//获取当前迭代器的下一个迭代器，注意，并不改变当前迭代器
Iterator GetNext(Iterator it);

//获取当前迭代器的上一个迭代器，注意，并不改变当前迭代器
Iterator GetLast(Iterator it);
为了更加清楚地表达这个链表的结构，下图所示的，就是该链表的结构：
调用InitList函数后，链表的结构如下：



当向链表中插入一定数量的结点后，链表的结构如下：



PS：其完整的代码可以点击这里下载：

三、如何实现隐藏链表的成员变量（即封装）
首先，我们为什么需要封装呢？我觉得封装主要有三大好处。

1）隔离变化，在程序中需要封装的通常是程序中最容易发生变化的地方，例如成员变量等，我们可以把它们封装起来，从而让它们的变化不会影响到系统的其他部分，也就是说，封装的是变化。

2）降低复杂度，因为我们把一个对象是如何实现的等细节封装起来，只留给用户一个最小依赖的接口，从而让系统变量简单明了，在一定程度降低了系统的复杂性，方便了用户的使用。

3）让用户只能按照我们设计好的接口来操作一个对象或类型，而不能自己直接对一个对象进行操作，从而减少了用户的误操作，提高了系统的稳定性。

在面向对象的设计中，如果我们想要隐藏一个类的成员变量，我们可以把这些成员变量声明为私有的，而在C语言中，我们可以怎么实现呢？其实其实现是很简单的，我们在C语言中，当我们要使用一个自己定义的类型或函数时，我们会把声明它的头文件包含（include）过来，只要我们在文件中只声明其类型是一个结构体，而把它的实现写在.c文件中即可。

在本例子中，我把struct list和struct node定义在.c文件中，而在头文件中，只声明其指针类型，即typedef struct node* Iterator和typedef struct list* List;当我们要使用该类型时，只需要在所在的文件中，include该头文件即可。因为在编译时，编译器只要知道List和Iterator是一个指针类型就能知道其所占的内存大小，也就能为其分配内存，所以能够编译成功。而又因为该头文件中并没有该类型（struct list和struct node）的定义，所以我们在使用该类型时，只能通过我们提供的接口来操作对象。例如，我们并不能使用List list; list->data等等的操作，而只能通过已定义的接口GetData来获得。

四、如何实现泛型
泛型，第一时间想起的可能是模板，但是在C语言中却没有这个东西。但是C语言中却有一个可以指向任何类型，在使用时，再根据具体的指针类型进行类型转换的指针类型，它就是void*。

为什么void*可以指向任何类型的数据？这还得从C语言对于数据类型的处理方式来说明。在C语言中，我们使用malloc等函数来申请内存，而从内存的角度来看，数据是没有类型的，它们都是一串的0或1，而程序则根据不同的类型来解释这个内存单元中的数据的意义，例如对于内存中的数据，FFFFFFFF，如果它是一个有符号整型数据，它代表的是-1，而如果它是一个无符号整型数据，它代表的则是2^32-1。进一步说，如果你用一个int的指针变量p指向该内存，则*p就是-1，如果你用unsigned int的指针p指向该内存，则*p = 2^32-1。

而我们使用malloc等函数时，也只需要说明申请的内存的大小即可，也不用说明申请的内存空间所存放的数据的类型，例如，我们申请一块内存空间来存放一个整型数据，则只需要malloc(sizeof(int))，即可，当然你完全可以把它当作一个具有4个单位的char数组来使用。所以我们可以使用void指针来指向我们申请的内存，申请内存的大小由链表中的成员data_size定义，它也是真正的data所占的内存大小。

五、为什么需要赋值函数指针assign
这里来说明一下，该链表的数据的插入方式，我们的插入方式是，新建一个结点，把data指向的数据复制到结点中，并把该结点插入到链表中。插入的函数定义如下：
Iterator Insert(List list, void *data, Iterator it_before,
                void (*assign)(void*, const void*));

从上面的解说中，我们可以看到链表中的成员data_size指示了链表中的数据所占的内存大小，那我们们就可以使用函数memcpy把data指向的数据复制到新建的结点的data所指向的内存即可。为什么还需要一个函数指针assign，来指向一个定义数据之间如何赋值的函数呢？其实这和面向对象语言中常说到的深复制和浅复制有关。

注：memcpy函数的原型为：void * memcpy ( void * destination, const void * source, size_t num );

试想一下，假如你的链表的数据类型不是int型等基本类型，也不是不含有指针的结构体，而是一个这样的结构体，例如：
struct student
{
    char *name;
    char *no;
    int age;
};
学生的姓名和学号都是能过动态分配内存而来的，并由student结构体中的name和no指针指向，那么当我们使用memcpy时，只能复制其指针，而不能复制其指向的数据，这样在很多情况下都会带来一定的问题。这个跟在C++中什么时候需要自己定义复制构造函数的情况类似。因为这种情况下，默认的复制构造函数并不能满足我们的需要，只能自己定义复制构造函数。

所以在插入一个结点时，需要assign函数指针的原理与C++中自己定义复制构造函数的原理一样。它用于定义如何根据一个已有的对象生成一个该对象的拷贝对象。当然，可能在大多数的情况下，我们需要用到的数据类型都没有包含指针，所以在Insert函数的实现中，其实我也是有用到memcpy函数的，就是当assign为NULL时，就使用memcpy函数进行数据对象间的赋值，它其实就相当于C++中的默认复制构造函数。assign为NULL表示使用默认的逐位复制方式。

六、为什么不用typedef

对于这个问题，其实很好回答。很多人实现一个通用链表是这样实现的，它们把node结构的实现如下：
typedef struct node
{
    //循环双链表的结点结构
    DataType data;//数据域指针
    struct node *next;//指向当前结点的下一结点
    struct node *last;//指向当前结点的上一结点
}Node;
然后，当需要使用整型的链表时，就把DataType用typedef为int。其实这样做的一个最大的缺陷就是一个程序中只能存在着一个数据类型的链表，例如，如果我需要一个int型的链表和一个float型的链表，那么该把DataType定义为int呢还是float呢？所以这种看似可行的方式，其实只是虚有其表，在现象中是行不能的，虽然不少的数据结构的书都是这样实现的，但是它却没有什么实用价值。

而其本质的原因是把结点的数据域的数据类型与某一种特定的数据类型DataType绑定在一起，从而让链表不能独立地变化。

七、为什么只把结点的指针定义为Iterator
在C++中iterator是一个类，为什么在这里，我只把结点的指针声明为一个Iterator呢？其实受STL的影响，我在一开始时，也是把Iterator实现为一个结构体，它只有一个数据成员，就是一个指向Node的指针。但在后来的实践中，发现其实并没有必要。在C++中为什么把iterator定义为一个类，是为了重载*，->等运行符，让iterator使用起来跟普通的指针一样。但是在C语言中，并没有重载运行符的做法，所以直接把Ierator声明为一个Node的指针最为方便、直接和好用，所有的比较运算都可以直接进行，而无需要借助函数。而把它声明为一个结构体反而麻烦、累赘。

八、为什么查找需要两个Iterator
其实这是参考了STL中的泛型算法的思想。而且本人觉得这是一种比较好的实现。为什么FindFirst的函数原型不是
Iterator FindFirst(List list,  int (*condition)(const void*, const void*));
而是
Iterator FindFirst(Iterator begin, Iterator end, void *data,
                       int (*condition)(const void*, const void*));
我们可以试想一下，这个链表的为char链表，链表的元素为ABCBCBC，我们要在链表中找出所有的B，如果查找算法是使用第一种定义的话，它只能找出第一个B，而后面的两个B就无能为力了，而第二种定义，则可以通过循环改变其始末迭代器来在不同的序列段间查找目标字符B的位置。 



list_v2.c

#include <stdlib.h>
#include <string.h>
#include "list_v2.h"

typedef struct node
{
    //循环双链表的结点结构
    void* data;//数据域指针
    struct node *next;//指向当前结点的下一结点
    struct node *last;//指向当前结点的上一结点
}Node;

struct list
{
    struct node *head;//头指针，指向头结点
    int data_size;//链表对应的数据所占内存的大小
    int length;//链表list的长度
};

static Node* Position(List list, int index);
static Node* NewNode(int data_size);
static void LinkNodeToList(List list, Node *node, Node *next_node);
static int RemoveNode(List list, Node *node);

int InitList(List *list_ptr, int data_size)
{
    /***
    函数功能：初始化链表,数据域所占内存的大小由data_size给出
    ***/

    List new_list = (List)malloc(sizeof(struct list));
    *list_ptr = new_list;
    if(new_list == NULL)
        return -1;

    Node *node = (Node*)malloc(sizeof(Node));
    if(node == NULL)
    {
        free(new_list);
        *list_ptr = NULL;
        return -1;
    }
    //把头结点的数据域指针置为空
    node->data = NULL;
    //使其指针指向自身
    node->next = node;
    node->last = node;
    //设置list的头指针、数据所占内存的大小和长度
    (*list_ptr)->head = node;
    (*list_ptr)->data_size = data_size;
    (*list_ptr)->length = 0;
    return 0;
}

Iterator Append(List list, void *data,
                void (*assign)(void*, const void*))
{
    /***
    函数功能：把data的内容插入到链表list的末尾
        assign指定数据data间的赋值方法
    ***/

    //调用Insert函数实现，插入位置为end
    return Insert(list, data, End(list), assign);
}

static void LinkNodeToList(List list, Node *node, Node *next_node)
{
    /***
    函数功能：把node连接到next_node之前
    ***/
    Node *last_node = next_node->last;
    //把node连接入list中
    //设置相关的结点的next指针
    last_node->next = node;
    node->next = next_node;
    //设置相关结点的last指针
    next_node->last = node;
    node->last = last_node;
    //把node的值连入list后，list的长度加1
    ++list->length;
}

static int RemoveNode(List list, Node *node)
{
    /***
    函数功能：从list中，移除node结点，但并不free
        注意，并不free结点，只是把结点从链中分离
    ***/
    if(node == list->head)
        return -1;//不移除头结点
    Node *next_node = node->next;
    Node *last_node = node->last;
    //使结点node从list中分离
    next_node->last = last_node;
    last_node->next = next_node;
    //分享后，list的长度减1
    --list->length;
    return 0;
}

static Node* Position(List list, int index)
{
    /***
    函数功能：返回第index个结点的指针
    ***/
    Node *node = NULL;
    int i = 0;
    //如果index比长度的一半小，则从前往后找
    if(index <= list->length>>1)
    {
        //设置node初值
        node = list->head->next;
        for(i = 0; i < index; ++i)
        {
            node = node->next;//向后移一个结点
        }
    }
    //否则从后往前找
    else
    {
        node = list->head;//设置node初值
        for(i = list->length; i > index; --i)
        {
            node = node->last;//向前移一个结点
        }
    }
    return node;
}

static Node* NewNode(int data_size)
{
    /***
    函数功能：新建一个结点，并返回结点的指针，
        结点由两部分组成，一部分是结点本身，
        一部分为data指针指向的数据域空间
        数据所占的内存空间由参数data_size给出
    ***/

    //创建结点，若创建失败，返回NULL
    Node *node = (Node*)malloc(sizeof(Node));
    if(node == NULL)
        return NULL;
    //创建数据域，若创建失败，返回NULL
    void *data = malloc(data_size);
    if(data == NULL)
    {
        free(node);
        return NULL;
    }
    //使结点的数据域指针指向数据域空间，并返回结点的指针
    node->data = data;
    return node;
}

Iterator Insert(List list, void *data, Iterator it_before,
                void (*assign)(void*, const void*))
{
    /***
    函数功能：把data的内容插入到链表list的迭代器it_before的前面
        assign指定数据data间的赋值方法
    ***/

    //从内存中开辟一个结点的空间
    Node *node = NewNode(list->data_size);
    if(node == NULL)
    {
        //若申请内存失败，则返回尾迭代器
        it_before = list->head;
        return it_before;
    }
    //设置结点的值
    if(assign == NULL)//使用默认的逐位复制方式，即浅复制
        memcpy(node->data, data, list->data_size);
    else    //使用用户定义的复制方式来复制数据
        assign(node->data, data);

    node->next = NULL;
    node->last = NULL;
    //把结点连入链表中
    LinkNodeToList(list, node, it_before);
    //返回连篇链表的结点的迭代器
    return node;
}

Iterator MoveFromAtoB(List A, Iterator it_a,
                      List B, Iterator it_b_before)
{
    /***
    函数功能：把链表A中迭代器it_a指向的结点移动到
              链表B中迭代器it_b_befroe的前面
    ***/

    //把结点a从A链中分享
    RemoveNode(A, it_a);
    //把结点a连接入B链中的结点b的前面
    LinkNodeToList(B, it_a, it_b_before);
    //返回连入链B的结点的指针
    return it_a;
}

int Remove(List list, Iterator it)
{
    /***
    函数功能：删除链表list中迭代器it指向的结点
    ***/

    //把结点it从list中分离
    int n = RemoveNode(list, it);
    if(n != -1)
    {
        free(it->data);
        free(it);//free掉node结点
    }
    return n;
}

int RemoveFirst(List list)
{
    /***
    函数功能：删除链表list的第0个结点，下标从0开始
    ***/
    return Remove(list, Begin(list));
}

int RemoveLast(List list)
{
    /***
    函数功能：删除链表list的最后一个结点
    ***/
    return Remove(list, End(list));
}

void* At(List list, int index)
{
    /***
    函数功能：返回list中第index个数据的指针
    ***/

    //获得第index个结点的指针
    Node *node = Position(list, index);
    if(node != list->head)
        return node->data;//返回数据域的指针
    return NULL;//若为头结点，则返回NULL
}

Iterator FindFirst(Iterator begin, Iterator end, void *data,
                       int (*condition)(const void*, const void*))
{
    /***
    函数功能：在begin和end之间查找符合condition的第一个元素，
      比较函数由condition指向,比较的值由data指向
      当第一个参数的值小于第二个参数的值时，返回1，否则返回0
      根据condition函数的不同，可以查找第一个相等、大于或小于data的值
    ***/
    while(begin != end)
    {
        //从开始到结束搜索
        if(condition(GetData(begin), data))
        {
            //找到符合数据的元素，退出循环
            break;
        }
        Next(&begin);
    }
    return begin;
}

int IndexOf(List list, void *data,
            int (*equal)(const void*,const void*))
{
    /***
    函数功能：查找list中第一个与data相等的元素的下标，
        equal函数，当第一个参数与第二个参数的值相等时，返回1，否则返回0
    ***/
    Node *node = list->head->next;//指向第0个结点
    int i = 0;
    while(node != list->head)
    {
        //从链表头到链表尾查找，若相等，则返回
        if(equal(data, node->data))
            return i;
        ++i;
        node = node->next;
    }
    //没有找到则返回-1
    return -1;
}

Iterator GetMin(Iterator begin, Iterator end,
                int (*less)(const void*, const void*))
{
    /***
    函数功能：查找在begin和end之间的最小值，比较函数由less指向
        当第一个参数的值小于第二个参数的值时，返回1，否则返回0
    ***/
    Iterator min = begin; //用于记录最小的元素的迭代器
    Next(&begin);
    while(begin != end)
    {
        //找到更小的元素，让min指向更小的元素
        if(less(GetData(begin), GetData(min)))
            min = begin;
        Next(&begin);
    }
    //返回最小的元素
    return min;
}

Iterator GetMax(Iterator begin, Iterator end,
                int (*large)(const void*, const void*))

{
    /***
    函数功能：查找在begin和end之间的最大值，比较函数由large指向
        当第一个参数的值大于第二个参数的值时，返回1，否则返回0
    ***/
    Iterator max = begin;//用于记录最大的元素的迭代器
    Next(&begin);
    while(begin != end)
    {
        //找到更大的元素，让max指向更小的元素
        if( large(GetData(begin), GetData(max)) )
            max = begin;
        Next(&begin);
    }
    //返回最大元素
    return max;
}

int GetLength(List list)
{
    /***
    函数功能：获取list的长度
    ***/
    return list->length;
}

int IsEmpty(List list)
{
    /***
    函数功能：若list为空链表，则返回1，否则返回0
    ***/
    return !(list->length);
}

void DestroyList(List *list_ptr)
{
    /***
    函数功能：销毁链表list
    ***/
    Node *node = (*list_ptr)->head->next;//指向第0个结点
    Node *end = (*list_ptr)->head;//指向尾结点
    Node *tmp = NULL;//用于保存被free的结点的下一个结点
    while(node != end)
    {
        //循环删除结点
        tmp = node->next;
        free(node->data);
        free(node);
        node = tmp;
    }
    //删除头结点
    free(end);
    free(*list_ptr);
    *list_ptr = NULL;
}

Iterator Begin(List list)
{
    /***
    函数功能：获得list的首迭代器
    ***/
    return list->head->next;
}

Iterator End(List list)
{
    /***
    函数功能：获得list的尾迭代器，指向最后一个元素的下一个位置
    ***/
    return list->head;
}

Iterator Next(Iterator *it)
{
    /***
    函数功能：使it指向下一个位置，并返回指向下一个位置后的迭代器
    ***/
    (*it) = (*it)->next;
    return *it;
}

Iterator Last(Iterator *it)
{
    /***
    函数功能：使it指向上一个位置，并返回指向上一个位置后的迭代器
    ***/
    (*it) = (*it)->last;
    return *it;
}

void* GetData(Iterator it)
{
    /***
    函数功能：通过迭代器it获得数据，相当于*p
    ***/
    return it->data;
}

Iterator GetNext(Iterator it)
{
    /***
    函数功能：
    获取当前迭代器的下一个迭代器，注意，并不改变当前迭代器
    ***/
    return it->next;
}

Iterator GetLast(Iterator it)
{
    /***
    函数功能：
    获取当前迭代器的上一个迭代器，注意，并不改变当前迭代器
    ***/
    return it->last;
}



头文件

#ifndef LIST_V2_H_INCLUDED
#define LIST_V2_H_INCLUDED

//泛型循环双链表，带头结点，结点下标从0开始，头结点不计入下标值

//定义结点指针Node*为List类型的迭代器
typedef struct node* Iterator;

//List类型的定义
typedef struct list* List;

//初始化链表,数据域所占内存的大小由data_size给出
int InitList(List *list, int data_size);

//把data的内容插入到链表list的末尾
//assign指定数据data间的赋值方法
Iterator Append(List list, void *data,
                void (*assign)(void*, const void*));

//把data的内容插入到链表的迭代器it_before的前面
//assign指定数据data间的赋值方法
Iterator Insert(List list, void *data, Iterator it_before,
                void (*assign)(void*, const void*));

//把链表A中迭代器it_a指向的结点移动到链表B中迭代器it_b_befroe的前面
Iterator MoveFromAtoB(List A, Iterator it_a,
                      List B, Iterator it_b_before);

//删除链表list中迭代器it指向的结点
int Remove(List list, Iterator it);

//删除链表list的第0个结点，下标从0开始
int RemoveFirst(List list);

//删除链表list的最后一个结点
int RemoveLast(List list);

//返回list中第index个数据的指针
void* At(List list, int index);

//在begin和end之间查找符合condition的第一个元素，
//比较函数由condition指向,比较的值由data指向
//当第一个参数的值小于第二个参数的值时，返回1，否则返回0
//根据condition函数的不同，可以查找第一个相等、大于或小于data的值
Iterator FindFirst(Iterator begin, Iterator end, void *data,
                       int (*condition)(const void*, const void*));

//查找list中第一个与data相等的元素的下标，
//equal函数，当第一个参数与第二个参数的值相等时，返回1，否则返回0
int IndexOf(List list, void *data,
            int (*equal)(const void*,const void*));

//查找在begin和end之间的最小值，比较函数由less指向
//当第一个参数的值小于第二个参数的值时，返回1，否则返回0
Iterator GetMin(Iterator begin, Iterator end,
                int (*less)(const void*, const void*));

//查找在begin和end之间的最大值，比较函数由large指向
//当第一个参数的值大于第二个参数的值时，返回1，否则返回0
Iterator GetMax(Iterator begin, Iterator end,
                int (*large)(const void*, const void*));

//获取list的长度
int GetLength(List list);
//若list为空链表，则返回1，否则返回0
int IsEmpty(List list);
//销毁list
void DestroyList(List *list);

//获得list的首迭代器
Iterator Begin(List list);

//获得list的尾迭代器，指向最后一个元素的下一个位置
Iterator End(List list);

//使it指向下一个位置，并返回指向下一个位置后的迭代器
Iterator Next(Iterator *it);

//使it指向上一个位置，并返回指向上一个位置后的迭代器
Iterator Last(Iterator *it);

//通过迭代器it获得数据，相当于*p
void* GetData(Iterator it);

//获取当前迭代器的下一个迭代器，注意，并不改变当前迭代器
Iterator GetNext(Iterator it);

//获取当前迭代器的上一个迭代器，注意，并不改变当前迭代器
Iterator GetLast(Iterator it);

#endif // LIST_H_INCLUDED


cuijinquan
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言泛型初探----C链表
lm_whales的专栏
11-06 1405
C语言泛型，可以仿照 C库函数 qsort 的方式 用户提供 一些回调函数。 数据结构不包含数据域， 数据域 由 内存的时候，多分配一些空间提供 数据域的地址：   节点指针 是 p，则数据域地址为 p+1； 下面，是个简单的单链表实现 #include #include #include ////类型定义 typedef struct LNode{     st
c语言 泛型链表,c语言是怎么实现泛型链表
weixin_29133151的博客
05-23 207
c语言是如何实现泛型链表最近有看一点Linux内核源码，发现内核里大量使用了list_head结构体。百度查了一下，原来内核利用这个结构体实现了泛型。自认为对链表已经很熟悉的我，决定自己实现一下。下面以Node和list_head为例。上图就是循环链大致思路了。(画的不好)我们通过list_head对链表进行移动操作。这里存在几个问题：首先通过list_head得到的指针，它指向的list_hea...
【C语言】【泛型】C语言技巧之如何实现泛型
最新发布
码农之家
05-28 785
- 本文简要介绍了C语言实现泛型的方法及几个典型的使用案例。
泛型链表——C语言实现
01-24
使用C语言实现的“泛型链表”，该链表为循环双链表，它的设计参考了C++的STL容器库中的容器list及泛型算法的接口，并使用迭代器来遍历链表。使用时只需要include头文件即可，隐藏了List类型的具体实现。用户并不需要知道链表的具体实现，只需要调用头文件中的接口来进行相应的操作即可。
C语言泛型链表
卖鱼的小白菜的专栏
04-11 896
不像 C++ 和 Java， C 语言不支持泛型。如何用C语言创建一条支持所有数据类型的链表？ 在C语言里，我们可以使用 void 指针和函数指针来支持泛型功能。void 指针最牛逼的地方就在于它支持各种数据类型，当然所有数据类型的指针大小都是一样的，所以我们总是可以创建一个指针节点。函数指针需要处理存储在 void 指针里这内容。下面是一个用 C 语言实现的泛型链表。
c语言是如何实现泛型链表
07-17
C语言实现泛型链表涉及到的核心概念包括结构体嵌入、宏定义、指针运算和函数指针。泛型链表允许程序员定义一种链表的数据结构，该数据结构能够存储任意类型的数据，而不必针对每种类型编写一个新的链表结构。这是...
纯C语言实现仿C++STL泛型链表
03-04
本文将深入探讨如何使用纯C语言来模仿C++ STL中的泛型链表实现。虽然C++ STL提供了模板类如`std::list`，在C语言中我们无法直接使用模板，但可以通过其他方式实现类似的功能。 首先，我们需要创建一个结构体来表示...
用C语言实现异质链表
12-15
通过上述描述和代码片段，我们可以了解到，虽然C语言缺乏泛型数据结构的支持，但通过结构体和联合体，我们可以模拟出类似于泛型链表的数据结构，从而实现一种可以存储不同类型数据的异质链表。这种实现方式需要仔细...
顺序存储和链式存储的泛型队列_C语言项目
04-12
本项目专注于实现顺序存储和链式存储的泛型队列，使用C语言作为编程工具，旨在提供灵活且高效的操作接口。下面我们将深入探讨相关知识点。 首先，队列是一种先进先出（First In First Out, FIFO）的数据结构，它的...
C语言 泛型链表的实现
Dontla的博客
06-28 449
参考文章：使用C语言实现“泛型”链表 文章目录jiang工给的泛型链表例子，有点看不怎么懂，自己写个看看：实现方法方法1：链表指针指向整个结点，结点中存放指向数据的指针方法2：结构体数据作为结点，结点中存放指向prev、next的指针（好像这样的话结构体数据确实不能直接作为结点） jiang工给的泛型链表例子，有点看不怎么懂，自己写个看看： #include <stdio.h> struct list_head { struct list_head *next, *prev; };
C语言实现泛型链表,C语言泛型初探----C链表
weixin_42567046的博客
05-22 259
C语言泛型，可以仿照 C库函数 qsort 的方式用户提供 一些回调函数。数据结构不包含数据域，数据域 由分配节点内存的时候，多分配一些空间提供数据域的地址：节点指针 是 p，则数据域地址为 p+1；下面，是个简单的单链表实现#include #include #include ////类型定义typedef struct LNode{struct LNode *next;}*PLNode,*Li...
如何使用C语言写: 泛型链表
dennis_fan的专栏
02-25 5190
C语言泛型设计的原则 ------------------------------------------------------------------------------------------------------------------------ 使用C语言编写通用数据结构相对比较困难.其一, C语言本身不支持泛型编程的特性;其二, C语言不支持元语言. C语言只能使用v
c语言通过宏实现类似c++的泛型编程效果——泛型链表
m0_65327603的博客
08-09 248
c模拟实现c++泛型编程
C 语言实现泛型的单链表--支持任意元素类型
weixin_46564301的博客
03-27 634
Linux内核源码剖析(一)--不同寻常的双向链表)，利用用户自定义的结构体包含 Linux 内核双链表节点，通过结构体元素偏移找到用户结构体起始位置，实现一种“泛型”链表。不过今天小 C 分享的是另外一种实现思路，请往下看~
C语言实现泛型-学习笔记
学习笔记专栏
04-01 942
#include #include"g_stack.h" GENERIC_STACK(int,_int,10) GENERIC_STACK(float,_float,5) int main() {     push_int(5);     push_int(22);     push_int(15);     push_float(25.3);     push_f
C语言的泛型
Jayccccc_chao的博客
02-25 4095
关于泛型：同一个函数可以处理不同类型的数据，这种方法就成为泛型。 这样可以避免相同方法，不同参数代码的冗余。 泛型的方式我了解的有两种：1.使用void来实现泛型 。2.使用宏实现泛型 来上段可视化代码： void实现 //一般的交换 void swap(int *a, int *b) { //这里省略一些参数检查 int tmp; tmp = *a; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值